diff options
40 files changed, 142 insertions, 618 deletions
diff --git a/chrome/browser/net/connection_tester.cc b/chrome/browser/net/connection_tester.cc index f23d619..18960eb 100644 --- a/chrome/browser/net/connection_tester.cc +++ b/chrome/browser/net/connection_tester.cc @@ -71,7 +71,6 @@ class ExperimentURLRequestContext : public URLRequestContext { dnsrr_resolver_, NULL /* dns_cert_checker */, NULL /* ssl_host_info_factory */, proxy_service_, ssl_config_service_, http_auth_handler_factory_, NULL, NULL), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); // In-memory cookie store. cookie_store_ = new net::CookieMonster(NULL, NULL); diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc index 21e2935..0d41479 100644 --- a/chrome/browser/net/passive_log_collector.cc +++ b/chrome/browser/net/passive_log_collector.cc @@ -70,7 +70,6 @@ PassiveLogCollector::PassiveLogCollector() trackers_[net::NetLog::SOURCE_HOST_RESOLVER_IMPL_REQUEST] = &dns_request_tracker_; trackers_[net::NetLog::SOURCE_HOST_RESOLVER_IMPL_JOB] = &dns_job_tracker_; - trackers_[net::NetLog::SOURCE_DISK_CACHE_ENTRY] = &disk_cache_entry_tracker_; // Make sure our mapping is up-to-date. for (size_t i = 0; i < arraysize(trackers_); ++i) DCHECK(trackers_[i]) << "Unhandled SourceType: " << i; @@ -561,28 +560,3 @@ PassiveLogCollector::DNSJobTracker::DoAddEntry(const ChromeNetLog::Entry& entry, return ACTION_NONE; } } - -//---------------------------------------------------------------------------- -// DiskCacheEntryTracker -//---------------------------------------------------------------------------- - -const size_t PassiveLogCollector::DiskCacheEntryTracker::kMaxNumSources = 100; -const size_t PassiveLogCollector::DiskCacheEntryTracker::kMaxGraveyardSize = 25; - -PassiveLogCollector::DiskCacheEntryTracker::DiskCacheEntryTracker() - : SourceTracker(kMaxNumSources, kMaxGraveyardSize, NULL) { -} - -PassiveLogCollector::SourceTracker::Action -PassiveLogCollector::DiskCacheEntryTracker::DoAddEntry( - const ChromeNetLog::Entry& entry, SourceInfo* out_info) { - AddEntryToSourceInfo(entry, out_info); - - // If the request has ended, move it to the graveyard. - if (entry.type == net::NetLog::TYPE_DISK_CACHE_ENTRY && - entry.phase == net::NetLog::PHASE_END) { - return ACTION_MOVE_TO_GRAVEYARD; - } - - return ACTION_NONE; -} diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h index a415d59..114e439 100644 --- a/chrome/browser/net/passive_log_collector.h +++ b/chrome/browser/net/passive_log_collector.h @@ -304,22 +304,6 @@ class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserver { DISALLOW_COPY_AND_ASSIGN(DNSJobTracker); }; - // Tracks the log entries for the last seen SOURCE_DISK_CACHE_ENTRY. - class DiskCacheEntryTracker : public SourceTracker { - public: - static const size_t kMaxNumSources; - static const size_t kMaxGraveyardSize; - - DiskCacheEntryTracker(); - - protected: - virtual Action DoAddEntry(const ChromeNetLog::Entry& entry, - SourceInfo* out_info); - - private: - DISALLOW_COPY_AND_ASSIGN(DiskCacheEntryTracker); - }; - PassiveLogCollector(); ~PassiveLogCollector(); @@ -356,7 +340,6 @@ class PassiveLogCollector : public ChromeNetLog::ThreadSafeObserver { SpdySessionTracker spdy_session_tracker_; DNSRequestTracker dns_request_tracker_; DNSJobTracker dns_job_tracker_; - DiskCacheEntryTracker disk_cache_entry_tracker_; // This array maps each NetLog::SourceType to one of the tracker instances // defined above. Use of this array avoid duplicating the list of trackers diff --git a/chrome/browser/resources/net_internals/logviewpainter.js b/chrome/browser/resources/net_internals/logviewpainter.js index 28df383..82686c6 100644 --- a/chrome/browser/resources/net_internals/logviewpainter.js +++ b/chrome/browser/resources/net_internals/logviewpainter.js @@ -49,9 +49,10 @@ function addSourceEntry_(node, sourceEntry) { function canCollapseBeginWithEnd(beginEntry) { return beginEntry && beginEntry.isBegin() && + !beginEntry.orig.params && beginEntry.end && beginEntry.end.index == beginEntry.index + 1 && - (!beginEntry.orig.params || !beginEntry.end.orig.params) && + !beginEntry.end.orig.params && beginEntry.orig.wasPassivelyCaptured == beginEntry.end.orig.wasPassivelyCaptured; } @@ -69,43 +70,43 @@ PrintSourceEntriesAsText = function(sourceEntries, doSecurityStripping) { for (var i = 0; i < entries.length; ++i) { var entry = entries[i]; - // Avoid printing the END for a BEGIN that was immediately before, unless - // both have extra parameters. - if (!entry.isEnd() || !canCollapseBeginWithEnd(entry.begin)) { - tablePrinter.addRow(); - - // Annotate this entry with "(P)" if it was passively captured. - tablePrinter.addCell(entry.orig.wasPassivelyCaptured ? '(P) ' : ''); - - tablePrinter.addCell('t='); - var date = g_browser.convertTimeTicksToDate(entry.orig.time) ; - var tCell = tablePrinter.addCell(date.getTime()); - tCell.alignRight = true; - tablePrinter.addCell(' [st='); - var stCell = tablePrinter.addCell(date.getTime() - startTime); - stCell.alignRight = true; - tablePrinter.addCell('] '); - - var indentationStr = makeRepeatedString(' ', entry.getDepth() * 3); - var mainCell = - tablePrinter.addCell(indentationStr + getTextForEvent(entry)); - tablePrinter.addCell(' '); - - // Get the elapsed time. - if (entry.isBegin()) { - tablePrinter.addCell('[dt='); - var dt = '?'; - // Definite time. - if (entry.end) { - dt = entry.end.orig.time - entry.orig.time; - } - var dtCell = tablePrinter.addCell(dt); - dtCell.alignRight = true; - - tablePrinter.addCell(']'); - } else { - mainCell.allowOverflow = true; + // Avoid printing the END for a BEGIN that was immediately before. + if (entry.isEnd() && canCollapseBeginWithEnd(entry.begin)) + continue; + + tablePrinter.addRow(); + + // Annotate this entry with "(P)" if it was passively captured. + tablePrinter.addCell(entry.orig.wasPassivelyCaptured ? '(P) ' : ''); + + tablePrinter.addCell('t='); + var date = g_browser.convertTimeTicksToDate(entry.orig.time) ; + var tCell = tablePrinter.addCell(date.getTime()); + tCell.alignRight = true; + tablePrinter.addCell(' [st='); + var stCell = tablePrinter.addCell(date.getTime() - startTime); + stCell.alignRight = true; + tablePrinter.addCell('] '); + + var indentationStr = makeRepeatedString(' ', entry.getDepth() * 3); + var mainCell = + tablePrinter.addCell(indentationStr + getTextForEvent(entry)); + tablePrinter.addCell(' '); + + // Get the elapsed time. + if (entry.isBegin()) { + tablePrinter.addCell('[dt='); + var dt = '?'; + // Definite time. + if (entry.end) { + dt = entry.end.orig.time - entry.orig.time; } + var dtCell = tablePrinter.addCell(dt); + dtCell.alignRight = true; + + tablePrinter.addCell(']'); + } else { + mainCell.allowOverflow = true; } // Output the extra parameters. diff --git a/chrome/browser/resources/net_internals/main.css b/chrome/browser/resources/net_internals/main.css index 8c6982c..be3abee 100644 --- a/chrome/browser/resources/net_internals/main.css +++ b/chrome/browser/resources/net_internals/main.css @@ -92,10 +92,6 @@ body { color: #308080; } -#eventsListTableBody .source_DISK_CACHE_ENTRY { - color: gray; -} - #eventsListTableBody .source_SOCKET { color: purple; } diff --git a/chrome/browser/resources/net_internals/sourceentry.js b/chrome/browser/resources/net_internals/sourceentry.js index 6c02c03..4a4df6e 100644 --- a/chrome/browser/resources/net_internals/sourceentry.js +++ b/chrome/browser/resources/net_internals/sourceentry.js @@ -232,9 +232,6 @@ SourceEntry.prototype.getDescription = function() { case LogSourceType.HOST_RESOLVER_IMPL_JOB: description = e.params.host; break; - case LogSourceType.DISK_CACHE_ENTRY: - description = e.params.key; - break; case LogSourceType.SPDY_SESSION: if (e.params.host) description = e.params.host + ' (' + e.params.proxy + ')'; diff --git a/chrome/service/net/service_url_request_context.cc b/chrome/service/net/service_url_request_context.cc index 46d3b7c..7f589e0 100644 --- a/chrome/service/net/service_url_request_context.cc +++ b/chrome/service/net/service_url_request_context.cc @@ -135,7 +135,6 @@ ServiceURLRequestContext::ServiceURLRequestContext( http_auth_handler_factory_, NULL /* network_delegate */, NULL /* net_log */), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); // In-memory cookie store. cookie_store_ = new net::CookieMonster(NULL, NULL); diff --git a/chrome/test/plugin/plugin_test.cpp b/chrome/test/plugin/plugin_test.cpp index 177ad5f..9aa885f 100644 --- a/chrome/test/plugin/plugin_test.cpp +++ b/chrome/test/plugin/plugin_test.cpp @@ -303,7 +303,6 @@ class PluginInstallerDownloadTest http_auth_handler_factory_, network_delegate_, NULL), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); } diff --git a/chrome_frame/metrics_service.cc b/chrome_frame/metrics_service.cc index e94b069..3311853 100644 --- a/chrome_frame/metrics_service.cc +++ b/chrome_frame/metrics_service.cc @@ -190,7 +190,6 @@ class ChromeFrameUploadRequestContext : public URLRequestContext { http_auth_handler_factory_, network_delegate_, NULL), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); } diff --git a/chrome_frame/test/test_server_test.cc b/chrome_frame/test/test_server_test.cc index 9040e22..0bb9ba2 100644 --- a/chrome_frame/test/test_server_test.cc +++ b/chrome_frame/test/test_server_test.cc @@ -81,7 +81,6 @@ class URLRequestTestContext : public URLRequestContext { http_auth_handler_factory_, NULL /* network_delegate */, NULL /* net_log */), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); // In-memory cookie store. cookie_store_ = new net::CookieMonster(NULL, NULL); diff --git a/net/base/capturing_net_log.cc b/net/base/capturing_net_log.cc index c6d34240..fccd5ae 100644 --- a/net/base/capturing_net_log.cc +++ b/net/base/capturing_net_log.cc @@ -18,9 +18,7 @@ CapturingNetLog::Entry::Entry(EventType type, CapturingNetLog::Entry::~Entry() {} CapturingNetLog::CapturingNetLog(size_t max_num_entries) - : last_id_(-1), - max_num_entries_(max_num_entries), - log_level_(LOG_ALL_BUT_BYTES) { + : last_id_(-1), max_num_entries_(max_num_entries) { } CapturingNetLog::~CapturingNetLog() {} @@ -41,8 +39,7 @@ uint32 CapturingNetLog::NextID() { } NetLog::LogLevel CapturingNetLog::GetLogLevel() const { - AutoLock lock(lock_); - return log_level_; + return LOG_ALL_BUT_BYTES; } void CapturingNetLog::GetEntries(EntryList* entry_list) const { @@ -55,11 +52,6 @@ void CapturingNetLog::Clear() { entries_.clear(); } -void CapturingNetLog::SetLogLevel(NetLog::LogLevel log_level) { - AutoLock lock(lock_); - log_level_ = log_level; -} - CapturingBoundNetLog::CapturingBoundNetLog(const NetLog::Source& source, CapturingNetLog* net_log) : source_(source), capturing_net_log_(net_log) { @@ -79,8 +71,4 @@ void CapturingBoundNetLog::Clear() { capturing_net_log_->Clear(); } -void CapturingBoundNetLog::SetLogLevel(NetLog::LogLevel log_level) { - capturing_net_log_->SetLogLevel(log_level); -} - } // namespace net diff --git a/net/base/capturing_net_log.h b/net/base/capturing_net_log.h index 193d641..9254725 100644 --- a/net/base/capturing_net_log.h +++ b/net/base/capturing_net_log.h @@ -61,8 +61,6 @@ class CapturingNetLog : public NetLog { void Clear(); - void SetLogLevel(NetLog::LogLevel log_level); - private: // Needs to be "mutable" so can use it in GetEntries(). mutable Lock lock_; @@ -73,8 +71,6 @@ class CapturingNetLog : public NetLog { size_t max_num_entries_; EntryList entries_; - NetLog::LogLevel log_level_; - DISALLOW_COPY_AND_ASSIGN(CapturingNetLog); }; @@ -101,9 +97,6 @@ class CapturingBoundNetLog { void Clear(); - // Sets the log level of the underlying CapturingNetLog. - void SetLogLevel(NetLog::LogLevel log_level); - private: NetLog::Source source_; scoped_ptr<CapturingNetLog> capturing_net_log_; diff --git a/net/base/net_log.cc b/net/base/net_log.cc index 0f1bac4..c9e7319 100644 --- a/net/base/net_log.cc +++ b/net/base/net_log.cc @@ -3,13 +3,11 @@ // found in the LICENSE file. #include "net/base/net_log.h" - #include "base/logging.h" #include "base/string_number_conversions.h" #include "base/time.h" #include "base/utf_string_conversions.h" #include "base/values.h" -#include "net/base/net_errors.h" namespace net { @@ -159,18 +157,6 @@ void BoundNetLog::EndEvent( AddEntry(event_type, NetLog::PHASE_END, params); } -void BoundNetLog::EndEventWithNetErrorCode(NetLog::EventType event_type, - int net_error) const { - DCHECK_NE(net_error, net::ERR_IO_PENDING); - if (net_error >= 0) { - EndEvent(event_type, NULL); - } else { - EndEvent( - event_type, - make_scoped_refptr(new NetLogIntegerParameter("net_error", net_error))); - } -} - // static BoundNetLog BoundNetLog::Make(NetLog* net_log, NetLog::SourceType source_type) { diff --git a/net/base/net_log.h b/net/base/net_log.h index 1d37129..b8f903d 100644 --- a/net/base/net_log.h +++ b/net/base/net_log.h @@ -34,8 +34,6 @@ namespace net { // TODO(eroman): Remove the 'const' qualitifer from the BoundNetLog methods. // TODO(eroman): Start a new Source each time net::URLRequest redirects // (simpler to reason about each as a separate entity). -// TODO(mmenke): Replace EndEvent calls with EndEventWithNetErrorCode, where -// appropriate. class NetLog { public: @@ -195,13 +193,6 @@ class BoundNetLog { void EndEvent(NetLog::EventType event_type, const scoped_refptr<NetLog::EventParameters>& params) const; - // Just like EndEvent, except |net_error| is a net error code. If it's - // negative, a parameter called "net_error" with a value of |net_error| is - // associated with the event. Otherwise, the end event has no parameters. - // |net_error| must not be ERR_IO_PENDING, as it's not a true error. - void EndEventWithNetErrorCode(NetLog::EventType event_type, - int net_error) const; - NetLog::LogLevel GetLogLevel() const; // Returns true if the log level is LOG_ALL. diff --git a/net/base/net_log_event_type_list.h b/net/base/net_log_event_type_list.h index 0f1eecf..f1bc4f8 100644 --- a/net/base/net_log_event_type_list.h +++ b/net/base/net_log_event_type_list.h @@ -501,85 +501,22 @@ EVENT_TYPE(URL_REQUEST_REDIRECTED) // HttpCache // ------------------------------------------------------------------------ -// Measures the time while getting a reference to the back end. -EVENT_TYPE(HTTP_CACHE_GET_BACKEND) - // Measures the time while opening a disk cache entry. EVENT_TYPE(HTTP_CACHE_OPEN_ENTRY) // Measures the time while creating a disk cache entry. EVENT_TYPE(HTTP_CACHE_CREATE_ENTRY) -// Measures the time it takes to add a HttpCache::Transaction to an http cache -// entry's list of active Transactions. -EVENT_TYPE(HTTP_CACHE_ADD_TO_ENTRY) - // Measures the time while deleting a disk cache entry. EVENT_TYPE(HTTP_CACHE_DOOM_ENTRY) -// Measures the time while reading/writing a disk cache entry's response headers -// or metadata. +// Measures the time while reading the response info from a disk cache entry. EVENT_TYPE(HTTP_CACHE_READ_INFO) -EVENT_TYPE(HTTP_CACHE_WRITE_INFO) - -// Measures the time while reading/writing a disk cache entry's body. -EVENT_TYPE(HTTP_CACHE_READ_DATA) -EVENT_TYPE(HTTP_CACHE_WRITE_DATA) - -// ------------------------------------------------------------------------ -// Disk Cache -// ------------------------------------------------------------------------ - -// The creation/destruction of a disk_cache::EntryImpl object. The "creation" -// is considered to be the point at which an Entry is first considered to be -// good and associated with a key. -// -// For the BEGIN phase, the following parameters are attached: -// { -// "created": <true if the Entry was created, rather than being opened>; -// "key": <The Entry's key>; -// } -EVENT_TYPE(DISK_CACHE_ENTRY) - -// Logs the time required to read/write data from/to a cache entry. -// -// For the BEGIN phase, the following parameters are attached: -// { -// "index": <Index being read/written>; -// "offset": <Offset being read/written>; -// "buf_len": <Length of buffer being read to/written from>; -// "truncate": <If present for a write, the truncate flag is set to true. -// Not present in reads or writes where it is false> -// } -// -// For the END phase, the following parameters are attached: -// { -// "bytes_copied": <Number of bytes copied. Not present on error>; -// "net_error": <Network error code. Only present on error>; -// } -EVENT_TYPE(DISK_CACHE_READ_DATA) -EVENT_TYPE(DISK_CACHE_WRITE_DATA) - -// Logged when SparseControl starts/stops handling IO for an Entry. -EVENT_TYPE(SPARSE_CONTROL) - -// Logged when SparseControl starts/stops reading/writing a child Entry's data -// -// For the BEGIN phase, the following parameters are attached: -// { -// "source_dependency": <Source id of the child entry> -// } -EVENT_TYPE(SPARSE_CONTROL_READ) -EVENT_TYPE(SPARSE_CONTROL_WRITE) - -// Indicates the time taken by a sparse control to get a range. -EVENT_TYPE(SPARSE_CONTROL_GET_RANGE) - -// Logged when an entry is closed. -EVENT_TYPE(DISK_CACHE_CLOSE) -// Logged when an entry is doomed. -EVENT_TYPE(DISK_CACHE_DOOM) +// Measures the time that an HttpCache::Transaction is stalled waiting for +// the cache entry to become available (for example if we are waiting for +// exclusive access to an existing entry). +EVENT_TYPE(HTTP_CACHE_WAITING) // ------------------------------------------------------------------------ // HttpNetworkTransaction diff --git a/net/base/net_log_source_type_list.h b/net/base/net_log_source_type_list.h index ba34955..231ecd2 100644 --- a/net/base/net_log_source_type_list.h +++ b/net/base/net_log_source_type_list.h @@ -15,6 +15,5 @@ SOURCE_TYPE(SOCKET, 5) SOURCE_TYPE(SPDY_SESSION, 6) SOURCE_TYPE(HOST_RESOLVER_IMPL_REQUEST, 7) SOURCE_TYPE(HOST_RESOLVER_IMPL_JOB, 8) -SOURCE_TYPE(DISK_CACHE_ENTRY, 9) -SOURCE_TYPE(COUNT, 10) // Always keep this as the last entry. +SOURCE_TYPE(COUNT, 9) // Always keep this as the last entry. diff --git a/net/disk_cache/backend_impl.cc b/net/disk_cache/backend_impl.cc index 223c970..58a6e9e 100644 --- a/net/disk_cache/backend_impl.cc +++ b/net/disk_cache/backend_impl.cc @@ -194,12 +194,11 @@ class CacheCreator { public: CacheCreator(const FilePath& path, bool force, int max_bytes, net::CacheType type, uint32 flags, - base::MessageLoopProxy* thread, net::NetLog* net_log, - disk_cache::Backend** backend, + base::MessageLoopProxy* thread, disk_cache::Backend** backend, net::CompletionCallback* callback) : path_(path), force_(force), retry_(false), max_bytes_(max_bytes), type_(type), flags_(flags), thread_(thread), backend_(backend), - callback_(callback), cache_(NULL), net_log_(net_log), + callback_(callback), cache_(NULL), ALLOW_THIS_IN_INITIALIZER_LIST( my_callback_(this, &CacheCreator::OnIOComplete)) { } @@ -224,14 +223,13 @@ class CacheCreator { disk_cache::Backend** backend_; net::CompletionCallback* callback_; disk_cache::BackendImpl* cache_; - net::NetLog* net_log_; net::CompletionCallbackImpl<CacheCreator> my_callback_; DISALLOW_COPY_AND_ASSIGN(CacheCreator); }; int CacheCreator::Run() { - cache_ = new disk_cache::BackendImpl(path_, thread_, net_log_); + cache_ = new disk_cache::BackendImpl(path_, thread_); cache_->SetMaxSize(max_bytes_); cache_->SetType(type_); cache_->SetFlags(flags_); @@ -297,8 +295,7 @@ namespace disk_cache { int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes, bool force, base::MessageLoopProxy* thread, - net::NetLog* net_log, Backend** backend, - CompletionCallback* callback) { + Backend** backend, CompletionCallback* callback) { DCHECK(callback); if (type == net::MEMORY_CACHE) { *backend = MemBackendImpl::CreateBackend(max_bytes); @@ -307,7 +304,7 @@ int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes, DCHECK(thread); return BackendImpl::CreateBackend(path, force, max_bytes, type, kNone, thread, - net_log, backend, callback); + backend, callback); } // Returns the preferred maximum number of bytes for the cache given the @@ -354,12 +351,11 @@ int PreferedCacheSize(int64 available) { int BackendImpl::CreateBackend(const FilePath& full_path, bool force, int max_bytes, net::CacheType type, uint32 flags, base::MessageLoopProxy* thread, - net::NetLog* net_log, Backend** backend, + Backend** backend, CompletionCallback* callback) { DCHECK(callback); CacheCreator* creator = new CacheCreator(full_path, force, max_bytes, type, - flags, thread, net_log, backend, - callback); + flags, thread, backend, callback); // This object will self-destroy when finished. return creator->Run(); } @@ -370,8 +366,7 @@ int BackendImpl::Init(CompletionCallback* callback) { } BackendImpl::BackendImpl(const FilePath& path, - base::MessageLoopProxy* cache_thread, - net::NetLog* net_log) + base::MessageLoopProxy* cache_thread) : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)), path_(path), block_files_(path), @@ -388,7 +383,6 @@ BackendImpl::BackendImpl(const FilePath& path, new_eviction_(false), first_timer_(true), throttle_requests_(false), - net_log_(net_log), done_(true, false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)), ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) { @@ -396,8 +390,7 @@ BackendImpl::BackendImpl(const FilePath& path, BackendImpl::BackendImpl(const FilePath& path, uint32 mask, - base::MessageLoopProxy* cache_thread, - net::NetLog* net_log) + base::MessageLoopProxy* cache_thread) : ALLOW_THIS_IN_INITIALIZER_LIST(background_queue_(this, cache_thread)), path_(path), block_files_(path), @@ -414,7 +407,6 @@ BackendImpl::BackendImpl(const FilePath& path, new_eviction_(false), first_timer_(true), throttle_requests_(false), - net_log_(net_log), done_(true, false), ALLOW_THIS_IN_INITIALIZER_LIST(factory_(this)), ALLOW_THIS_IN_INITIALIZER_LIST(ptr_factory_(this)) { @@ -856,8 +848,6 @@ EntryImpl* BackendImpl::CreateEntryImpl(const std::string& key) { return NULL; } - cache_entry->BeginLogging(net_log_, true); - // We are not failing the operation; let's add this to the map. open_entries_[entry_address.value()] = cache_entry; @@ -1547,7 +1537,6 @@ int BackendImpl::NewEntry(Addr address, EntryImpl** entry, bool* dirty) { open_entries_[address.value()] = cache_entry; } - cache_entry->BeginLogging(net_log_, false); cache_entry.swap(entry); return 0; } diff --git a/net/disk_cache/backend_impl.h b/net/disk_cache/backend_impl.h index b481525..5637fbd 100644 --- a/net/disk_cache/backend_impl.h +++ b/net/disk_cache/backend_impl.h @@ -19,10 +19,6 @@ #include "net/disk_cache/stats.h" #include "net/disk_cache/trace.h" -namespace net { -class NetLog; -} // namespace net - namespace disk_cache { enum BackendFlags { @@ -42,11 +38,10 @@ enum BackendFlags { class BackendImpl : public Backend { friend class Eviction; public: - BackendImpl(const FilePath& path, base::MessageLoopProxy* cache_thread, - net::NetLog* net_log); + BackendImpl(const FilePath& path, base::MessageLoopProxy* cache_thread); // mask can be used to limit the usable size of the hash table, for testing. BackendImpl(const FilePath& path, uint32 mask, - base::MessageLoopProxy* cache_thread, net::NetLog* net_log); + base::MessageLoopProxy* cache_thread); ~BackendImpl(); // Returns a new backend with the desired flags. See the declaration of @@ -54,8 +49,7 @@ class BackendImpl : public Backend { static int CreateBackend(const FilePath& full_path, bool force, int max_bytes, net::CacheType type, uint32 flags, base::MessageLoopProxy* thread, - net::NetLog* net_log, Backend** backend, - CompletionCallback* callback); + Backend** backend, CompletionCallback* callback); // Performs general initialization for this current instance of the cache. int Init(CompletionCallback* callback); @@ -363,8 +357,6 @@ class BackendImpl : public Backend { bool first_timer_; // True if the timer has not been called. bool throttle_requests_; - net::NetLog* net_log_; - Stats stats_; // Usage statistcs. base::RepeatingTimer<BackendImpl> timer_; // Usage timer. base::WaitableEvent done_; // Signals the end of background work. diff --git a/net/disk_cache/backend_unittest.cc b/net/disk_cache/backend_unittest.cc index eaa00eb..9077996 100644 --- a/net/disk_cache/backend_unittest.cc +++ b/net/disk_cache/backend_unittest.cc @@ -195,7 +195,7 @@ TEST_F(DiskCacheTest, CreateBackend) { disk_cache::Backend* cache = NULL; int rv = disk_cache::BackendImpl::CreateBackend( path, false, 0, net::DISK_CACHE, disk_cache::kNoRandom, - cache_thread.message_loop_proxy(), NULL, &cache, &cb); + cache_thread.message_loop_proxy(), &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); ASSERT_TRUE(cache); delete cache; @@ -208,14 +208,14 @@ TEST_F(DiskCacheTest, CreateBackend) { // Now test the public API. rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false, cache_thread.message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); ASSERT_TRUE(cache); delete cache; cache = NULL; rv = disk_cache::CreateCacheBackend(net::MEMORY_CACHE, FilePath(), 0, false, - NULL, NULL, &cache, &cb); + NULL, &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); ASSERT_TRUE(cache); delete cache; @@ -260,8 +260,7 @@ TEST_F(DiskCacheTest, ShutdownWithPendingIO) { disk_cache::Backend* cache; int rv = disk_cache::BackendImpl::CreateBackend( path, false, 0, net::DISK_CACHE, disk_cache::kNoRandom, - base::MessageLoopProxy::CreateForCurrentThread(), NULL, - &cache, &cb); + base::MessageLoopProxy::CreateForCurrentThread(), &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); disk_cache::EntryImpl* entry; @@ -312,7 +311,7 @@ TEST_F(DiskCacheTest, ShutdownWithPendingIO2) { disk_cache::Backend* cache; int rv = disk_cache::BackendImpl::CreateBackend( path, false, 0, net::DISK_CACHE, disk_cache::kNoRandom, - cache_thread.message_loop_proxy(), NULL, &cache, &cb); + cache_thread.message_loop_proxy(), &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); disk_cache::Entry* entry; @@ -349,7 +348,7 @@ TEST_F(DiskCacheTest, TruncatedIndex) { disk_cache::Backend* backend = NULL; int rv = disk_cache::BackendImpl::CreateBackend( path, false, 0, net::DISK_CACHE, disk_cache::kNone, - cache_thread.message_loop_proxy(), NULL, &backend, &cb); + cache_thread.message_loop_proxy(), &backend, &cb); ASSERT_NE(net::OK, cb.GetResult(rv)); ASSERT_TRUE(backend == NULL); @@ -1279,7 +1278,7 @@ TEST_F(DiskCacheTest, DeleteOld) { disk_cache::Backend* cache; int rv = disk_cache::BackendImpl::CreateBackend( path, true, 0, net::DISK_CACHE, disk_cache::kNoRandom, - cache_thread.message_loop_proxy(), NULL, &cache, &cb); + cache_thread.message_loop_proxy(), &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); MessageLoopHelper helper; @@ -1652,8 +1651,7 @@ TEST_F(DiskCacheTest, Backend_UsageStats) { ASSERT_TRUE(DeleteCache(path)); scoped_ptr<disk_cache::BackendImpl> cache; cache.reset(new disk_cache::BackendImpl( - path, base::MessageLoopProxy::CreateForCurrentThread(), - NULL)); + path, base::MessageLoopProxy::CreateForCurrentThread())); ASSERT_TRUE(NULL != cache.get()); cache->SetUnitTestMode(); ASSERT_EQ(net::OK, cache->SyncInit()); @@ -1771,11 +1769,11 @@ TEST_F(DiskCacheTest, MultipleInstances) { int rv = disk_cache::BackendImpl::CreateBackend( store1.path(), false, 0, net::DISK_CACHE, disk_cache::kNone, - cache_thread.message_loop_proxy(), NULL, &cache[0], &cb); + cache_thread.message_loop_proxy(), &cache[0], &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); rv = disk_cache::BackendImpl::CreateBackend( store2.path(), false, 0, net::MEDIA_CACHE, disk_cache::kNone, - cache_thread.message_loop_proxy(), NULL, &cache[1], &cb); + cache_thread.message_loop_proxy(), &cache[1], &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); ASSERT_TRUE(cache[0] != NULL && cache[1] != NULL); diff --git a/net/disk_cache/disk_cache.h b/net/disk_cache/disk_cache.h index 18dd447..59efe06 100644 --- a/net/disk_cache/disk_cache.h +++ b/net/disk_cache/disk_cache.h @@ -25,7 +25,6 @@ class MessageLoopProxy; namespace net { class IOBuffer; -class NetLog; } namespace disk_cache { @@ -51,8 +50,7 @@ typedef net::CompletionCallback CompletionCallback; // completes (the callback is notified). int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes, bool force, base::MessageLoopProxy* thread, - net::NetLog* net_log, Backend** backend, - CompletionCallback* callback); + Backend** backend, CompletionCallback* callback); // The root interface for a disk cache instance. class Backend { diff --git a/net/disk_cache/disk_cache_perftest.cc b/net/disk_cache/disk_cache_perftest.cc index 14f15c6..241fc04 100644 --- a/net/disk_cache/disk_cache_perftest.cc +++ b/net/disk_cache/disk_cache_perftest.cc @@ -169,7 +169,7 @@ TEST_F(DiskCacheTest, CacheBackendPerformance) { disk_cache::Backend* cache; int rv = disk_cache::CreateCacheBackend( net::DISK_CACHE, test_cache.path(), 0, false, - cache_thread.message_loop_proxy(), NULL, &cache, &cb); + cache_thread.message_loop_proxy(), &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); @@ -198,7 +198,7 @@ TEST_F(DiskCacheTest, CacheBackendPerformance) { rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, test_cache.path(), 0, false, cache_thread.message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); ret = TimeRead(num_entries, cache, entries, true); diff --git a/net/disk_cache/disk_cache_test_base.cc b/net/disk_cache/disk_cache_test_base.cc index 6c9b91c..cffe3fa 100644 --- a/net/disk_cache/disk_cache_test_base.cc +++ b/net/disk_cache/disk_cache_test_base.cc @@ -75,7 +75,7 @@ void DiskCacheTestWithCache::InitDiskCache() { TestCompletionCallback cb; int rv = disk_cache::BackendImpl::CreateBackend( path, force_creation_, size_, type_, - disk_cache::kNoRandom, thread, NULL, &cache_, &cb); + disk_cache::kNoRandom, thread, &cache_, &cb); ASSERT_EQ(net::OK, cb.GetResult(rv)); } @@ -84,9 +84,9 @@ void DiskCacheTestWithCache::InitDiskCacheImpl(const FilePath& path) { use_current_thread_ ? base::MessageLoopProxy::CreateForCurrentThread() : cache_thread_.message_loop_proxy(); if (mask_) - cache_impl_ = new disk_cache::BackendImpl(path, mask_, thread, NULL); + cache_impl_ = new disk_cache::BackendImpl(path, mask_, thread); else - cache_impl_ = new disk_cache::BackendImpl(path, thread, NULL); + cache_impl_ = new disk_cache::BackendImpl(path, thread); cache_ = cache_impl_; ASSERT_TRUE(NULL != cache_); diff --git a/net/disk_cache/disk_cache_test_util.cc b/net/disk_cache/disk_cache_test_util.cc index ed16db0..76690e6 100644 --- a/net/disk_cache/disk_cache_test_util.cc +++ b/net/disk_cache/disk_cache_test_util.cc @@ -94,7 +94,7 @@ bool CopyTestCache(const std::string& name) { bool CheckCacheIntegrity(const FilePath& path, bool new_eviction) { scoped_ptr<disk_cache::BackendImpl> cache(new disk_cache::BackendImpl( - path, base::MessageLoopProxy::CreateForCurrentThread(), NULL)); + path, base::MessageLoopProxy::CreateForCurrentThread())); if (!cache.get()) return false; if (new_eviction) diff --git a/net/disk_cache/entry_impl.cc b/net/disk_cache/entry_impl.cc index 3cb895f..e5e6482 100644 --- a/net/disk_cache/entry_impl.cc +++ b/net/disk_cache/entry_impl.cc @@ -7,7 +7,6 @@ #include "base/message_loop.h" #include "base/metrics/histogram.h" #include "base/string_util.h" -#include "base/values.h" #include "net/base/io_buffer.h" #include "net/base/net_errors.h" #include "net/disk_cache/backend_impl.h" @@ -25,93 +24,14 @@ namespace { // Index for the file used to store the key, if any (files_[kKeyFileIndex]). const int kKeyFileIndex = 3; -// NetLog parameters for the creation of an EntryImpl. Contains an entry's name -// and whether it was created or opened. -class EntryCreationParameters : public net::NetLog::EventParameters { - public: - EntryCreationParameters(const std::string& key, bool created) - : key_(key), created_(created) { - } - - Value* ToValue() const { - DictionaryValue* dict = new DictionaryValue(); - dict->SetString("key", key_); - dict->SetBoolean("created", created_); - return dict; - } - - private: - const std::string key_; - const bool created_; - - DISALLOW_COPY_AND_ASSIGN(EntryCreationParameters); -}; - -// NetLog parameters for non-sparse reading and writing to an EntryImpl. -class ReadWriteDataParams : public net::NetLog::EventParameters { - public: - // For reads, |truncate| must be false. - ReadWriteDataParams(int index, int offset, int buf_len, bool truncate) - : index_(index), offset_(offset), buf_len_(buf_len), truncate_(truncate) { - } - - Value* ToValue() const { - DictionaryValue* dict = new DictionaryValue(); - dict->SetInteger("index", index_); - dict->SetInteger("offset", offset_); - dict->SetInteger("buf_len", buf_len_); - if (truncate_) - dict->SetBoolean("truncate", truncate_); - return dict; - } - - private: - const int index_; - const int offset_; - const int buf_len_; - const bool truncate_; - - DISALLOW_COPY_AND_ASSIGN(ReadWriteDataParams); -}; - -// NetLog parameters logged when non-sparse reads and writes complete. -class FileIOCompleteParameters : public net::NetLog::EventParameters { - public: - // |bytes_copied| is either the number of bytes copied or a network error - // code. |bytes_copied| must not be ERR_IO_PENDING, as it's not a valid - // result for an operation. - explicit FileIOCompleteParameters(int bytes_copied) - : bytes_copied_(bytes_copied) { - } - - Value* ToValue() const { - DCHECK_NE(bytes_copied_, net::ERR_IO_PENDING); - DictionaryValue* dict = new DictionaryValue(); - if (bytes_copied_ < 0) { - dict->SetInteger("net_error", bytes_copied_); - } else { - dict->SetInteger("bytes_copied", bytes_copied_); - } - return dict; - } - - private: - const int bytes_copied_; - - DISALLOW_COPY_AND_ASSIGN(FileIOCompleteParameters); -}; - // This class implements FileIOCallback to buffer the callback from a file IO // operation from the actual net class. class SyncCallback: public disk_cache::FileIOCallback { public: - // |end_event_type| is the event type to log on completion. Logs nothing on - // discard, or when the NetLog is not set to log all events. SyncCallback(disk_cache::EntryImpl* entry, net::IOBuffer* buffer, - net::CompletionCallback* callback, - net::NetLog::EventType end_event_type) + net::CompletionCallback* callback ) : entry_(entry), callback_(callback), buf_(buffer), - start_(TimeTicks::Now()), end_event_type_(end_event_type) { + start_(TimeTicks::Now()) { entry->AddRef(); entry->IncrementIoCount(); } @@ -119,13 +39,11 @@ class SyncCallback: public disk_cache::FileIOCallback { virtual void OnFileIOComplete(int bytes_copied); void Discard(); - private: disk_cache::EntryImpl* entry_; net::CompletionCallback* callback_; scoped_refptr<net::IOBuffer> buf_; TimeTicks start_; - net::NetLog::EventType end_event_type_; DISALLOW_COPY_AND_ASSIGN(SyncCallback); }; @@ -133,11 +51,6 @@ class SyncCallback: public disk_cache::FileIOCallback { void SyncCallback::OnFileIOComplete(int bytes_copied) { entry_->DecrementIoCount(); if (callback_) { - if (entry_->net_log().IsLoggingAllEvents()) { - entry_->net_log().EndEvent( - end_event_type_, - make_scoped_refptr(new FileIOCompleteParameters(bytes_copied))); - } entry_->ReportIOTime(disk_cache::EntryImpl::kAsyncIO, start_); callback_->Run(bytes_copied); } @@ -395,7 +308,6 @@ EntryImpl::~EntryImpl() { if (doomed_) { DeleteEntryData(true); } else { - net_log_.AddEvent(net::NetLog::TYPE_DISK_CACHE_CLOSE, NULL); bool ret = true; for (int index = 0; index < kNumStreams; index++) { if (user_buffers_[index].get()) { @@ -421,7 +333,6 @@ EntryImpl::~EntryImpl() { } Trace("~EntryImpl out 0x%p", reinterpret_cast<void*>(this)); - net_log_.EndEvent(net::NetLog::TYPE_DISK_CACHE_ENTRY, NULL); backend_->OnEntryDestroyEnd(); } @@ -576,46 +487,6 @@ void EntryImpl::DoomImpl() { int EntryImpl::ReadDataImpl(int index, int offset, net::IOBuffer* buf, int buf_len, CompletionCallback* callback) { - if (net_log_.IsLoggingAllEvents()) { - net_log_.BeginEvent( - net::NetLog::TYPE_DISK_CACHE_READ_DATA, - make_scoped_refptr( - new ReadWriteDataParams(index, offset, buf_len, false))); - } - - int result = InternalReadData(index, offset, buf, buf_len, callback); - - if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) { - net_log_.EndEvent( - net::NetLog::TYPE_DISK_CACHE_READ_DATA, - make_scoped_refptr(new FileIOCompleteParameters(result))); - } - return result; -} - -int EntryImpl::WriteDataImpl(int index, int offset, net::IOBuffer* buf, - int buf_len, CompletionCallback* callback, - bool truncate) { - if (net_log_.IsLoggingAllEvents()) { - net_log_.BeginEvent( - net::NetLog::TYPE_DISK_CACHE_WRITE_DATA, - make_scoped_refptr( - new ReadWriteDataParams(index, offset, buf_len, truncate))); - } - - int result = InternalWriteData(index, offset, buf, buf_len, callback, - truncate); - - if (result != net::ERR_IO_PENDING && net_log_.IsLoggingAllEvents()) { - net_log_.EndEvent( - net::NetLog::TYPE_DISK_CACHE_WRITE_DATA, - make_scoped_refptr(new FileIOCompleteParameters(result))); - } - return result; -} - -int EntryImpl::InternalReadData(int index, int offset, net::IOBuffer* buf, - int buf_len, CompletionCallback* callback) { DCHECK(node_.Data()->dirty || read_only_); DVLOG(2) << "Read from " << index << " at " << offset << " : " << buf_len; if (index < 0 || index >= kNumStreams) @@ -665,10 +536,8 @@ int EntryImpl::InternalReadData(int index, int offset, net::IOBuffer* buf, } SyncCallback* io_callback = NULL; - if (callback) { - io_callback = new SyncCallback(this, buf, callback, - net::NetLog::TYPE_DISK_CACHE_READ_DATA); - } + if (callback) + io_callback = new SyncCallback(this, buf, callback); bool completed; if (!file->Read(buf->data(), buf_len, file_offset, io_callback, &completed)) { @@ -684,9 +553,9 @@ int EntryImpl::InternalReadData(int index, int offset, net::IOBuffer* buf, return (completed || !callback) ? buf_len : net::ERR_IO_PENDING; } -int EntryImpl::InternalWriteData(int index, int offset, net::IOBuffer* buf, - int buf_len, CompletionCallback* callback, - bool truncate) { +int EntryImpl::WriteDataImpl(int index, int offset, net::IOBuffer* buf, + int buf_len, CompletionCallback* callback, + bool truncate) { DCHECK(node_.Data()->dirty || read_only_); DVLOG(2) << "Write to " << index << " at " << offset << " : " << buf_len; if (index < 0 || index >= kNumStreams) @@ -759,10 +628,8 @@ int EntryImpl::InternalWriteData(int index, int offset, net::IOBuffer* buf, return 0; SyncCallback* io_callback = NULL; - if (callback) { - io_callback = new SyncCallback(this, buf, callback, - net::NetLog::TYPE_DISK_CACHE_WRITE_DATA); - } + if (callback) + io_callback = new SyncCallback(this, buf, callback); bool completed; if (!file->Write(buf->data(), buf_len, file_offset, io_callback, @@ -890,7 +757,6 @@ bool EntryImpl::IsSameEntry(const std::string& key, uint32 hash) { } void EntryImpl::InternalDoom() { - net_log_.AddEvent(net::NetLog::TYPE_DISK_CACHE_DOOM, NULL); DCHECK(node_.HasData()); if (!node_.Data()->dirty) { node_.Data()->dirty = backend_->GetCurrentEntryId(); @@ -1048,19 +914,6 @@ void EntryImpl::ReportIOTime(Operation op, const base::TimeTicks& start) { } } -void EntryImpl::BeginLogging(net::NetLog* net_log, bool created) { - DCHECK(!net_log_.net_log()); - net_log_ = net::BoundNetLog::Make( - net_log, net::NetLog::SOURCE_DISK_CACHE_ENTRY); - net_log_.BeginEvent( - net::NetLog::TYPE_DISK_CACHE_ENTRY, - make_scoped_refptr(new EntryCreationParameters(GetKey(), created))); -} - -const net::BoundNetLog& EntryImpl::net_log() const { - return net_log_; -} - // ------------------------------------------------------------------------ bool EntryImpl::CreateDataBlock(int index, int size) { diff --git a/net/disk_cache/entry_impl.h b/net/disk_cache/entry_impl.h index d24e861..e27f23a 100644 --- a/net/disk_cache/entry_impl.h +++ b/net/disk_cache/entry_impl.h @@ -7,7 +7,6 @@ #pragma once #include "base/scoped_ptr.h" -#include "net/base/net_log.h" #include "net/disk_cache/disk_cache.h" #include "net/disk_cache/storage_block.h" #include "net/disk_cache/storage_block-inl.h" @@ -130,14 +129,6 @@ class EntryImpl : public Entry, public base::RefCounted<EntryImpl> { // Generates a histogram for the time spent working on this operation. void ReportIOTime(Operation op, const base::TimeTicks& start); - // Logs a begin event and enables logging for the EntryImpl. Will also cause - // an end event to be logged on destruction. The EntryImpl must have its key - // initialized before this is called. |created| is true if the Entry was - // created rather than opened. - void BeginLogging(net::NetLog* net_log, bool created); - - const net::BoundNetLog& net_log() const; - private: enum { kNumStreams = 3 @@ -146,13 +137,6 @@ class EntryImpl : public Entry, public base::RefCounted<EntryImpl> { ~EntryImpl(); - // Do all the work for ReadDataImpl and WriteDataImpl. Implemented as - // separate functions to make logging of results simpler. - int InternalReadData(int index, int offset, net::IOBuffer* buf, - int buf_len, CompletionCallback* callback); - int InternalWriteData(int index, int offset, net::IOBuffer* buf, int buf_len, - CompletionCallback* callback, bool truncate); - // Initializes the storage for an internal or external data block. bool CreateDataBlock(int index, int size); @@ -236,8 +220,6 @@ class EntryImpl : public Entry, public base::RefCounted<EntryImpl> { bool read_only_; // True if not yet writing. scoped_ptr<SparseControl> sparse_; // Support for sparse entries. - net::BoundNetLog net_log_; - DISALLOW_COPY_AND_ASSIGN(EntryImpl); }; diff --git a/net/disk_cache/sparse_control.cc b/net/disk_cache/sparse_control.cc index c200b82..32f44ab 100644 --- a/net/disk_cache/sparse_control.cc +++ b/net/disk_cache/sparse_control.cc @@ -138,29 +138,6 @@ void ChildrenDeleter::DeleteChildren() { this, &ChildrenDeleter::DeleteChildren)); } -// Logs the end event for |operation|, if all events are being logged. -void LogOperationEnd(const net::BoundNetLog& net_log, - disk_cache::SparseControl::SparseOperation operation, - int result) { - if (net_log.IsLoggingAllEvents()) { - net::NetLog::EventType event_type; - switch (operation) { - case disk_cache::SparseControl::kReadOperation: - event_type = net::NetLog::TYPE_SPARSE_CONTROL_READ; - break; - case disk_cache::SparseControl::kWriteOperation: - event_type = net::NetLog::TYPE_SPARSE_CONTROL_WRITE; - break; - case disk_cache::SparseControl::kGetRangeOperation: - event_type = net::NetLog::TYPE_SPARSE_CONTROL_GET_RANGE; - break; - default: - NOTREACHED(); - } - net_log.EndEventWithNetErrorCode(event_type, result); - } -} - } // namespace. namespace disk_cache { @@ -246,7 +223,6 @@ int SparseControl::StartIO(SparseOperation op, int64 offset, net::IOBuffer* buf, finished_ = false; abort_ = false; - entry_->net_log().BeginEvent(net::NetLog::TYPE_SPARSE_CONTROL, NULL); DoChildrenIO(); if (!pending_) { @@ -634,11 +610,8 @@ void SparseControl::InitChildData() { void SparseControl::DoChildrenIO() { while (DoChildIO()) continue; - if (finished_) { - entry_->net_log().EndEvent(net::NetLog::TYPE_SPARSE_CONTROL, NULL); - if (pending_) - DoUserCallback(); - } + if (pending_ && finished_) + DoUserCallback(); } bool SparseControl::DoChildIO() { @@ -659,32 +632,14 @@ bool SparseControl::DoChildIO() { int rv = 0; switch (operation_) { case kReadOperation: - if (entry_->net_log().IsLoggingAllEvents()) { - entry_->net_log().BeginEvent( - net::NetLog::TYPE_SPARSE_CONTROL_READ, - make_scoped_refptr(new net::NetLogSourceParameter( - "source_dependency", - child_->net_log().source()))); - } rv = child_->ReadDataImpl(kSparseData, child_offset_, user_buf_, child_len_, callback); break; case kWriteOperation: - if (entry_->net_log().IsLoggingAllEvents()) { - entry_->net_log().BeginEvent( - net::NetLog::TYPE_SPARSE_CONTROL_WRITE, - make_scoped_refptr(new net::NetLogSourceParameter( - "source_dependency", - child_->net_log().source()))); - } rv = child_->WriteDataImpl(kSparseData, child_offset_, user_buf_, child_len_, callback, false); break; case kGetRangeOperation: - if (entry_->net_log().IsLoggingAllEvents()) { - entry_->net_log().BeginEvent(net::NetLog::TYPE_SPARSE_CONTROL_GET_RANGE, - NULL); - } rv = DoGetAvailableRange(); break; default: @@ -757,7 +712,6 @@ int SparseControl::DoGetAvailableRange() { } void SparseControl::DoChildIOCompleted(int result) { - LogOperationEnd(entry_->net_log(), operation_, result); if (result < 0) { // We fail the whole operation if we encounter an error. result_ = result; @@ -783,8 +737,6 @@ void SparseControl::OnChildIOCompleted(int result) { // We'll return the current result of the operation, which may be less than // the bytes to read or write, but the user cancelled the operation. abort_ = false; - entry_->net_log().AddEvent(net::NetLog::TYPE_CANCELLED, NULL); - entry_->net_log().EndEvent(net::NetLog::TYPE_SPARSE_CONTROL, NULL); DoUserCallback(); return DoAbortCallbacks(); } diff --git a/net/disk_cache/stress_cache.cc b/net/disk_cache/stress_cache.cc index ee2db24..41a98c9 100644 --- a/net/disk_cache/stress_cache.cc +++ b/net/disk_cache/stress_cache.cc @@ -104,7 +104,7 @@ void StressTheCache(int iteration) { int rv = disk_cache::BackendImpl::CreateBackend( path, false, cache_size, net::DISK_CACHE, disk_cache::kNoLoadProtection | disk_cache::kNoRandom, - cache_thread.message_loop_proxy(), NULL, &cache, &cb); + cache_thread.message_loop_proxy(), &cache, &cb); if (cb.GetResult(rv) != net::OK) { printf("Unable to initialize cache.\n"); diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc index 5710491..51cc55f 100644 --- a/net/http/http_cache.cc +++ b/net/http/http_cache.cc @@ -55,18 +55,17 @@ HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) { return new DefaultBackend(MEMORY_CACHE, FilePath(), max_bytes, NULL); } -int HttpCache::DefaultBackend::CreateBackend(NetLog* net_log, - disk_cache::Backend** backend, +int HttpCache::DefaultBackend::CreateBackend(disk_cache::Backend** backend, CompletionCallback* callback) { DCHECK_GE(max_bytes_, 0); return disk_cache::CreateCacheBackend(type_, path_, max_bytes_, true, - thread_, net_log, backend, callback); + thread_, backend, callback); } //----------------------------------------------------------------------------- -HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* entry) - : disk_entry(entry), +HttpCache::ActiveEntry::ActiveEntry(disk_cache::Entry* e) + : disk_entry(e), writer(NULL), will_process_pending_queue(false), doomed(false) { @@ -289,8 +288,7 @@ HttpCache::HttpCache(HostResolver* host_resolver, HttpNetworkDelegate* network_delegate, NetLog* net_log, BackendFactory* backend_factory) - : net_log_(net_log), - backend_factory_(backend_factory), + : backend_factory_(backend_factory), building_backend_(false), mode_(NORMAL), ssl_host_info_factory_(new SSLHostInfoFactoryAdaptor( @@ -305,8 +303,7 @@ HttpCache::HttpCache(HostResolver* host_resolver, HttpCache::HttpCache(HttpNetworkSession* session, BackendFactory* backend_factory) - : net_log_(session->net_log()), - backend_factory_(backend_factory), + : backend_factory_(backend_factory), building_backend_(false), mode_(NORMAL), network_layer_(HttpNetworkLayer::CreateFactory(session)), @@ -314,10 +311,8 @@ HttpCache::HttpCache(HttpNetworkSession* session, } HttpCache::HttpCache(HttpTransactionFactory* network_layer, - NetLog* net_log, BackendFactory* backend_factory) - : net_log_(net_log), - backend_factory_(backend_factory), + : backend_factory_(backend_factory), building_backend_(false), mode_(NORMAL), network_layer_(network_layer), @@ -469,8 +464,7 @@ int HttpCache::CreateBackend(disk_cache::Backend** backend, BackendCallback* my_callback = new BackendCallback(this, pending_op); pending_op->callback = my_callback; - int rv = backend_factory_->CreateBackend(net_log_, &pending_op->backend, - my_callback); + int rv = backend_factory_->CreateBackend(&pending_op->backend, my_callback); if (rv != ERR_IO_PENDING) { pending_op->writer->ClearCallback(); my_callback->Run(rv); diff --git a/net/http/http_cache.h b/net/http/http_cache.h index 0641ca4..8ff6442 100644 --- a/net/http/http_cache.h +++ b/net/http/http_cache.h @@ -87,8 +87,7 @@ class HttpCache : public HttpTransactionFactory, // notification arrives. // The implementation must not access the factory object after invoking the // |callback| because the object can be deleted from within the callback. - virtual int CreateBackend(NetLog* net_log, - disk_cache::Backend** backend, + virtual int CreateBackend(disk_cache::Backend** backend, CompletionCallback* callback) = 0; }; @@ -106,8 +105,7 @@ class HttpCache : public HttpTransactionFactory, static BackendFactory* InMemory(int max_bytes); // BackendFactory implementation. - virtual int CreateBackend(NetLog* net_log, - disk_cache::Backend** backend, + virtual int CreateBackend(disk_cache::Backend** backend, CompletionCallback* callback); private: @@ -142,7 +140,6 @@ class HttpCache : public HttpTransactionFactory, // by the HttpCache and will be destroyed using |delete| when the HttpCache is // destroyed. HttpCache(HttpTransactionFactory* network_layer, - NetLog* net_log, BackendFactory* backend_factory); HttpTransactionFactory* network_layer() { return network_layer_.get(); } @@ -218,7 +215,7 @@ class HttpCache : public HttpTransactionFactory, bool will_process_pending_queue; bool doomed; - explicit ActiveEntry(disk_cache::Entry* entry); + explicit ActiveEntry(disk_cache::Entry*); ~ActiveEntry(); }; @@ -347,8 +344,6 @@ class HttpCache : public HttpTransactionFactory, // Variables ---------------------------------------------------------------- - NetLog* net_log_; - // Used when lazily constructing the disk_cache_. scoped_ptr<BackendFactory> backend_factory_; bool building_backend_; diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc index b506edc..d795c83 100644 --- a/net/http/http_cache_transaction.cc +++ b/net/http/http_cache_transaction.cc @@ -398,10 +398,6 @@ LoadState HttpCache::Transaction::GetWriterLoadState() const { return LOAD_STATE_WAITING_FOR_CACHE; } -const BoundNetLog& HttpCache::Transaction::net_log() const { - return net_log_; -} - //----------------------------------------------------------------------------- void HttpCache::Transaction::DoCallback(int rv) { @@ -583,14 +579,13 @@ int HttpCache::Transaction::DoLoop(int result) { int HttpCache::Transaction::DoGetBackend() { cache_pending_ = true; next_state_ = STATE_GET_BACKEND_COMPLETE; - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_GET_BACKEND, NULL); + net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL); return cache_->GetBackendForTransaction(this); } int HttpCache::Transaction::DoGetBackendComplete(int result) { DCHECK(result == OK || result == ERR_FAILED); - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_GET_BACKEND, - result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL); cache_pending_ = false; if (!ShouldPassThrough()) { @@ -762,7 +757,7 @@ int HttpCache::Transaction::DoOpenEntryComplete(int result) { // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is // OK, otherwise the cache will end up with an active entry without any // transaction attached. - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY, result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY, NULL); cache_pending_ = false; if (result == OK) { next_state_ = STATE_ADD_TO_ENTRY; @@ -805,8 +800,7 @@ int HttpCache::Transaction::DoCreateEntryComplete(int result) { // It is important that we go to STATE_ADD_TO_ENTRY whenever the result is // OK, otherwise the cache will end up with an active entry without any // transaction attached. - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY, - result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY, NULL); cache_pending_ = false; next_state_ = STATE_ADD_TO_ENTRY; @@ -837,7 +831,7 @@ int HttpCache::Transaction::DoDoomEntry() { } int HttpCache::Transaction::DoDoomEntryComplete(int result) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY, result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY, NULL); next_state_ = STATE_CREATE_ENTRY; cache_pending_ = false; if (result == ERR_CACHE_RACE) @@ -850,15 +844,14 @@ int HttpCache::Transaction::DoAddToEntry() { DCHECK(new_entry_); cache_pending_ = true; next_state_ = STATE_ADD_TO_ENTRY_COMPLETE; - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY, NULL); + net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL); DCHECK(entry_lock_waiting_since_.is_null()); entry_lock_waiting_since_ = base::TimeTicks::Now(); return cache_->AddTransactionToEntry(new_entry_, this); } int HttpCache::Transaction::DoAddToEntryComplete(int result) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY, - result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_WAITING, NULL); const base::TimeDelta entry_lock_wait = base::TimeTicks::Now() - entry_lock_waiting_since_; @@ -1009,19 +1002,12 @@ int HttpCache::Transaction::DoTruncateCachedData() { cache_callback_->AddRef(); // Balanced in DoTruncateCachedDataComplete. if (!entry_) return OK; - if (net_log_.IsLoggingAllEvents()) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA, NULL); // Truncate the stream. return WriteToEntry(kResponseContentIndex, 0, NULL, 0, cache_callback_); } int HttpCache::Transaction::DoTruncateCachedDataComplete(int result) { - if (net_log_.IsLoggingAllEvents() && entry_) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_DATA, - result); - } - // Balance the AddRef from DoTruncateCachedData. cache_callback_->Release(); next_state_ = STATE_TRUNCATE_CACHED_METADATA; @@ -1034,17 +1020,10 @@ int HttpCache::Transaction::DoTruncateCachedMetadata() { if (!entry_) return OK; - if (net_log_.IsLoggingAllEvents()) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, NULL); return WriteToEntry(kMetadataIndex, 0, NULL, 0, cache_callback_); } int HttpCache::Transaction::DoTruncateCachedMetadataComplete(int result) { - if (net_log_.IsLoggingAllEvents() && entry_) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, - result); - } - // Balance the AddRef from DoTruncateCachedMetadata. cache_callback_->Release(); @@ -1094,7 +1073,7 @@ int HttpCache::Transaction::DoCacheReadResponse() { int HttpCache::Transaction::DoCacheReadResponseComplete(int result) { cache_callback_->Release(); // Balance the AddRef from DoCacheReadResponse. - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO, NULL); if (result != io_buf_len_ || !HttpCache::ParseResponseInfo(read_buf_->data(), io_buf_len_, &response_, &truncated_)) { @@ -1134,14 +1113,10 @@ int HttpCache::Transaction::DoCacheReadResponseComplete(int result) { } int HttpCache::Transaction::DoCacheWriteResponse() { - if (net_log_.IsLoggingAllEvents() && entry_) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, NULL); return WriteResponseInfoToEntry(false); } int HttpCache::Transaction::DoCacheWriteTruncatedResponse() { - if (net_log_.IsLoggingAllEvents() && entry_) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, NULL); return WriteResponseInfoToEntry(true); } @@ -1150,10 +1125,6 @@ int HttpCache::Transaction::DoCacheWriteResponseComplete(int result) { target_state_ = STATE_NONE; if (!entry_) return OK; - if (net_log_.IsLoggingAllEvents()) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_INFO, - result); - } // Balance the AddRef from WriteResponseInfoToEntry. write_headers_callback_->Release(); @@ -1181,7 +1152,7 @@ int HttpCache::Transaction::DoCacheReadMetadata() { int HttpCache::Transaction::DoCacheReadMetadataComplete(int result) { cache_callback_->Release(); // Balance the AddRef from DoCacheReadMetadata. - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_INFO, result); + net_log_.EndEvent(NetLog::TYPE_HTTP_CACHE_READ_INFO, NULL); if (result != response_.metadata->size()) { DLOG(ERROR) << "ReadData failed: " << result; return ERR_CACHE_READ_FAILURE; @@ -1212,9 +1183,6 @@ int HttpCache::Transaction::DoCacheReadData() { DCHECK(entry_); next_state_ = STATE_CACHE_READ_DATA_COMPLETE; cache_callback_->AddRef(); // Balanced in DoCacheReadDataComplete. - - if (net_log_.IsLoggingAllEvents()) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_READ_DATA, NULL); if (partial_.get()) { return partial_->CacheRead(entry_->disk_entry, read_buf_, io_buf_len_, cache_callback_); @@ -1226,10 +1194,6 @@ int HttpCache::Transaction::DoCacheReadData() { int HttpCache::Transaction::DoCacheReadDataComplete(int result) { cache_callback_->Release(); // Balance the AddRef from DoCacheReadData. - if (net_log_.IsLoggingAllEvents()) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_READ_DATA, - result); - } if (!cache_) return ERR_UNEXPECTED; @@ -1249,18 +1213,12 @@ int HttpCache::Transaction::DoCacheReadDataComplete(int result) { int HttpCache::Transaction::DoCacheWriteData(int num_bytes) { next_state_ = STATE_CACHE_WRITE_DATA_COMPLETE; write_len_ = num_bytes; - if (net_log_.IsLoggingAllEvents() && entry_) - net_log_.BeginEvent(NetLog::TYPE_HTTP_CACHE_WRITE_DATA, NULL); cache_callback_->AddRef(); // Balanced in DoCacheWriteDataComplete. return AppendResponseDataToEntry(read_buf_, num_bytes, cache_callback_); } int HttpCache::Transaction::DoCacheWriteDataComplete(int result) { - if (net_log_.IsLoggingAllEvents() && entry_) { - net_log_.EndEventWithNetErrorCode(NetLog::TYPE_HTTP_CACHE_WRITE_DATA, - result); - } // Balance the AddRef from DoCacheWriteData. cache_callback_->Release(); if (!cache_) diff --git a/net/http/http_cache_transaction.h b/net/http/http_cache_transaction.h index 316c15b..6b46750 100644 --- a/net/http/http_cache_transaction.h +++ b/net/http/http_cache_transaction.h @@ -110,8 +110,6 @@ class HttpCache::Transaction : public HttpTransaction { CompletionCallback* io_callback() { return &io_callback_; } - const BoundNetLog& net_log() const; - private: static const size_t kNumValidationHeaders = 2; // Helper struct to pair a header name with its value, for diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc index bf8cb6b..a40a5b8 100644 --- a/net/http/http_cache_unittest.cc +++ b/net/http/http_cache_unittest.cc @@ -536,8 +536,7 @@ class MockDiskCache : public disk_cache::Backend { class MockBackendFactory : public net::HttpCache::BackendFactory { public: - virtual int CreateBackend(net::NetLog* /* net_log */, - disk_cache::Backend** backend, + virtual int CreateBackend(disk_cache::Backend** backend, net::CompletionCallback* callback) { *backend = new MockDiskCache(); return net::OK; @@ -547,11 +546,11 @@ class MockBackendFactory : public net::HttpCache::BackendFactory { class MockHttpCache { public: MockHttpCache() - : http_cache_(new MockNetworkLayer(), NULL, new MockBackendFactory()) { + : http_cache_(new MockNetworkLayer(), new MockBackendFactory()) { } explicit MockHttpCache(net::HttpCache::BackendFactory* disk_cache_factory) - : http_cache_(new MockNetworkLayer(), NULL, disk_cache_factory) { + : http_cache_(new MockNetworkLayer(), disk_cache_factory) { } net::HttpCache* http_cache() { return &http_cache_; } @@ -611,8 +610,7 @@ class MockHttpCache { } // Helper function to synchronously create a backend entry. - bool CreateBackendEntry(const std::string& key, disk_cache::Entry** entry, - net::NetLog* /* net_log */) { + bool CreateBackendEntry(const std::string& key, disk_cache::Entry** entry) { TestCompletionCallback cb; int rv = disk_cache()->CreateEntry(key, entry, &cb); return (cb.GetResult(rv) == net::OK); @@ -632,8 +630,7 @@ class MockDiskCacheNoCB : public MockDiskCache { class MockBackendNoCbFactory : public net::HttpCache::BackendFactory { public: - virtual int CreateBackend(net::NetLog* /* net_log */, - disk_cache::Backend** backend, + virtual int CreateBackend(disk_cache::Backend** backend, net::CompletionCallback* callback) { *backend = new MockDiskCacheNoCB(); return net::OK; @@ -646,8 +643,7 @@ class MockBlockingBackendFactory : public net::HttpCache::BackendFactory { MockBlockingBackendFactory() : backend_(NULL), callback_(NULL), block_(true), fail_(false) {} - virtual int CreateBackend(net::NetLog* /* net_log */, - disk_cache::Backend** backend, + virtual int CreateBackend(disk_cache::Backend** backend, net::CompletionCallback* callback) { if (!block_) { if (!fail_) @@ -1041,7 +1037,6 @@ TEST(HttpCache, SimpleGETNoDiskCache) { cache.disk_cache()->set_fail_requests(); net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded); - log.SetLogLevel(net::NetLog::LOG_BASIC); // Read from the network, and don't use the cache. RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction, @@ -1054,9 +1049,9 @@ TEST(HttpCache, SimpleGETNoDiskCache) { EXPECT_EQ(6u, entries.size()); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsBeginEvent( entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY)); EXPECT_TRUE(net::LogContainsEndEvent( @@ -1148,9 +1143,6 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) { net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded); - // This prevents a number of write events from being logged. - log.SetLogLevel(net::NetLog::LOG_BASIC); - // write to the cache RunTransactionTestWithLog(cache.http_cache(), kSimpleGET_Transaction, log.bound()); @@ -1161,9 +1153,9 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) { EXPECT_EQ(8u, entries.size()); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsBeginEvent( entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY)); EXPECT_TRUE(net::LogContainsEndEvent( @@ -1173,9 +1165,9 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) { EXPECT_TRUE(net::LogContainsEndEvent( entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY)); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 6, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 6, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 7, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 7, net::NetLog::TYPE_HTTP_CACHE_WAITING)); // force this transaction to read from the cache MockTransaction transaction(kSimpleGET_Transaction); @@ -1190,17 +1182,17 @@ TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Hit) { EXPECT_EQ(8u, entries.size()); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsBeginEvent( entries, 2, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY)); EXPECT_TRUE(net::LogContainsEndEvent( entries, 3, net::NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY)); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 4, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 4, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 5, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 5, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsBeginEvent( entries, 6, net::NetLog::TYPE_HTTP_CACHE_READ_INFO)); EXPECT_TRUE(net::LogContainsEndEvent( @@ -1281,9 +1273,6 @@ TEST(HttpCache, SimpleGET_LoadBypassCache) { net::CapturingBoundNetLog log(net::CapturingNetLog::kUnbounded); - // This prevents a number of write events from being logged. - log.SetLogLevel(net::NetLog::LOG_BASIC); - RunTransactionTestWithLog(cache.http_cache(), transaction, log.bound()); // Check that the NetLog was filled as expected. @@ -1292,9 +1281,9 @@ TEST(HttpCache, SimpleGET_LoadBypassCache) { EXPECT_EQ(8u, entries.size()); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 0, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 0, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 1, net::NetLog::TYPE_HTTP_CACHE_GET_BACKEND)); + entries, 1, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsBeginEvent( entries, 2, net::NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY)); EXPECT_TRUE(net::LogContainsEndEvent( @@ -1304,9 +1293,9 @@ TEST(HttpCache, SimpleGET_LoadBypassCache) { EXPECT_TRUE(net::LogContainsEndEvent( entries, 5, net::NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY)); EXPECT_TRUE(net::LogContainsBeginEvent( - entries, 6, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 6, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_TRUE(net::LogContainsEndEvent( - entries, 7, net::NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY)); + entries, 7, net::NetLog::TYPE_HTTP_CACHE_WAITING)); EXPECT_EQ(2, cache.network_layer()->transaction_count()); EXPECT_EQ(0, cache.disk_cache()->open_count()); @@ -3313,8 +3302,7 @@ TEST(HttpCache, GET_Previous206_NotSparse) { // Create a disk cache entry that stores 206 headers while not being sparse. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kSimpleGET_Transaction.url, &entry)); std::string raw_headers(kRangeGET_TransactionOK.status); raw_headers.append("\n"); @@ -3357,8 +3345,7 @@ TEST(HttpCache, RangeGET_Previous206_NotSparse_2) { // Create a disk cache entry that stores 206 headers while not being sparse. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry)); std::string raw_headers(kRangeGET_TransactionOK.status); raw_headers.append("\n"); @@ -3956,8 +3943,7 @@ TEST(HttpCache, RangeGET_OK_LoadOnlyFromCache) { TEST(HttpCache, WriteResponseInfo_Truncated) { MockHttpCache cache; disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry("http://www.google.com", &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry("http://www.google.com", &entry)); std::string headers("HTTP/1.1 200 OK"); headers = net::HttpUtil::AssembleRawHeaders(headers.data(), headers.size()); @@ -4156,8 +4142,7 @@ TEST(HttpCache, GET_IncompleteResource) { // Create a disk cache entry that stores an incomplete resource. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry)); std::string raw_headers("HTTP/1.1 200 OK\n" "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n" @@ -4217,8 +4202,7 @@ TEST(HttpCache, GET_IncompleteResource2) { // Create a disk cache entry that stores an incomplete resource. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry)); // Content-length will be intentionally bad. @@ -4277,8 +4261,7 @@ TEST(HttpCache, GET_CancelIncompleteResource) { // Create a disk cache entry that stores an incomplete resource. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry)); std::string raw_headers("HTTP/1.1 200 OK\n" "Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n" @@ -4343,8 +4326,7 @@ TEST(HttpCache, RangeGET_IncompleteResource) { // Create a disk cache entry that stores an incomplete resource. disk_cache::Entry* entry; - ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry, - NULL)); + ASSERT_TRUE(cache.CreateBackendEntry(kRangeGET_TransactionOK.url, &entry)); // Content-length will be intentionally bogus. std::string raw_headers("HTTP/1.1 200 OK\n" diff --git a/net/http/http_network_session.h b/net/http/http_network_session.h index b36d7f7..5a3b96c 100644 --- a/net/http/http_network_session.h +++ b/net/http/http_network_session.h @@ -130,10 +130,6 @@ class HttpNetworkSession : public base::RefCounted<HttpNetworkSession>, return &http_stream_factory_; } - NetLog* net_log() { - return net_log_; - } - // Creates a Value summary of the state of the socket pools. The caller is // responsible for deleting the returned value. Value* SocketPoolInfoToValue() const { diff --git a/net/proxy/proxy_script_fetcher_impl_unittest.cc b/net/proxy/proxy_script_fetcher_impl_unittest.cc index 043f71e..ec0fb58 100644 --- a/net/proxy/proxy_script_fetcher_impl_unittest.cc +++ b/net/proxy/proxy_script_fetcher_impl_unittest.cc @@ -47,7 +47,6 @@ class RequestContext : public URLRequestContext { net::HttpNetworkLayer::CreateFactory(host_resolver_, cert_verifier_, NULL, NULL, NULL, proxy_service_, ssl_config_service_, NULL, NULL, NULL), - NULL, net::HttpCache::DefaultBackend::InMemory(0)); } diff --git a/net/spdy/spdy_test_util.h b/net/spdy/spdy_test_util.h index 1b052fa..aeabe6a 100644 --- a/net/spdy/spdy_test_util.h +++ b/net/spdy/spdy_test_util.h @@ -419,7 +419,6 @@ class SpdyURLRequestContext : public URLRequestContext { http_auth_handler_factory_, network_delegate_, NULL), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); } diff --git a/net/tools/crash_cache/crash_cache.cc b/net/tools/crash_cache/crash_cache.cc index 40c6a41..44672ed 100644 --- a/net/tools/crash_cache/crash_cache.cc +++ b/net/tools/crash_cache/crash_cache.cc @@ -135,7 +135,7 @@ int SimpleInsert(const FilePath& path, RankCrashes action, disk_cache::Backend* cache; int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, path, 0, false, cache_thread->message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); if (cb.GetResult(rv) != net::OK || cache->GetEntryCount()) return GENERIC; @@ -176,7 +176,7 @@ int SimpleRemove(const FilePath& path, RankCrashes action, // Use a simple LRU for eviction. int rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE, path, 0, false, cache_thread->message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); if (cb.GetResult(rv) != net::OK || cache->GetEntryCount()) return GENERIC; @@ -219,7 +219,7 @@ int HeadRemove(const FilePath& path, RankCrashes action, // Use a simple LRU for eviction. int rv = disk_cache::CreateCacheBackend(net::MEDIA_CACHE, path, 0, false, cache_thread->message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); if (cb.GetResult(rv) != net::OK || cache->GetEntryCount()) return GENERIC; @@ -256,7 +256,7 @@ int LoadOperations(const FilePath& path, RankCrashes action, // Work with a tiny index table (16 entries). disk_cache::BackendImpl* cache = new disk_cache::BackendImpl( - path, 0xf, cache_thread->message_loop_proxy(), NULL); + path, 0xf, cache_thread->message_loop_proxy()); if (!cache || !cache->SetMaxSize(0x100000)) return GENERIC; diff --git a/net/tools/dump_cache/upgrade.cc b/net/tools/dump_cache/upgrade.cc index fae924c..30fbc8c6 100644 --- a/net/tools/dump_cache/upgrade.cc +++ b/net/tools/dump_cache/upgrade.cc @@ -326,7 +326,7 @@ bool MasterSM::DoInit() { FilePath::FromWStringHack(path_), 0, false, cache_thread_.message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); if (cb.GetResult(rv) != net::OK) { printf("Unable to initialize new files\n"); return false; @@ -607,7 +607,7 @@ SlaveSM::SlaveSM(const std::wstring& path, HANDLE channel) FilePath::FromWStringHack(path), 0, false, cache_thread_.message_loop_proxy(), - NULL, &cache, &cb); + &cache, &cb); if (cb.GetResult(rv) != net::OK) { printf("Unable to open cache files\n"); return; diff --git a/net/url_request/url_request_unittest.h b/net/url_request/url_request_unittest.h index c336b41..b13d268 100644 --- a/net/url_request/url_request_unittest.h +++ b/net/url_request/url_request_unittest.h @@ -173,7 +173,6 @@ class TestURLRequestContext : public URLRequestContext { http_auth_handler_factory_, network_delegate_, NULL), - NULL /* net_log */, net::HttpCache::DefaultBackend::InMemory(0)); // In-memory cookie store. cookie_store_ = new net::CookieMonster(NULL, NULL); diff --git a/net/url_request/view_cache_helper_unittest.cc b/net/url_request/view_cache_helper_unittest.cc index 3903c2b..5338ee5 100644 --- a/net/url_request/view_cache_helper_unittest.cc +++ b/net/url_request/view_cache_helper_unittest.cc @@ -25,7 +25,7 @@ class TestURLRequestContext : public URLRequestContext { }; TestURLRequestContext::TestURLRequestContext() - : cache_(reinterpret_cast<net::HttpTransactionFactory*>(NULL), NULL, + : cache_(reinterpret_cast<net::HttpTransactionFactory*>(NULL), net::HttpCache::DefaultBackend::InMemory(0)) { http_transaction_factory_ = &cache_; } diff --git a/webkit/appcache/appcache_disk_cache.cc b/webkit/appcache/appcache_disk_cache.cc index 9aa0280..dbba211 100644 --- a/webkit/appcache/appcache_disk_cache.cc +++ b/webkit/appcache/appcache_disk_cache.cc @@ -108,7 +108,7 @@ int AppCacheDiskCache::Init(net::CacheType cache_type, this, &AppCacheDiskCache::OnCreateBackendComplete); int rv = disk_cache::CreateCacheBackend( - cache_type, cache_directory, cache_size, force, cache_thread, NULL, + cache_type, cache_directory, cache_size, force, cache_thread, &(create_backend_callback_->backend_ptr_), create_backend_callback_); if (rv == net::ERR_IO_PENDING) init_callback_ = callback; |