Add a source id to global NetLog entries.

net/url_request/url_request_throttler_manager.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/url_request/url_request_throttler_manager.h"
 
 #include "base/logging.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 47 matching lines @@
     // We only disable back-off throttling on an entry that we have
     // just constructed.  This is to allow unit tests to explicitly override
     // the entry for localhost URLs.  Given that we do not attempt to
     // disable throttling for entries already handed out (see comment
     // in AddToOptOutList), this is not a problem.
     std::string host = url.host();
     if (opt_out_hosts_.find(host) != opt_out_hosts_.end() ||
         IsLocalhost(host)) {
       if (!logged_for_localhost_disabled_ && IsLocalhost(host)) {
         logged_for_localhost_disabled_ = true;
-        net_log_->AddEvent(
+        net_log_.AddEvent(
             NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
             make_scoped_refptr(new NetLogStringParameter("host", host)));
       }
 
       // TODO(joi): Once sliding window is separate from back-off throttling,
       // we can simply return a dummy implementation of
       // URLRequestThrottlerEntryInterface here that never blocks anything (and
       // not keep entries in url_entries_ for opted-out sites).
       entry->DisableBackoffThrottling();
     }
   }
 
   return entry;
 }
 
 void URLRequestThrottlerManager::AddToOptOutList(const std::string& host) {
   // There is an edge case here that we are not handling, to keep things
   // simple.  If a host starts adding the opt-out header to its responses
   // after there are already one or more entries in url_entries_ for that
   // host, the pre-existing entries may still perform back-off throttling.
   // In practice, this would almost never occur.
   if (opt_out_hosts_.find(host) == opt_out_hosts_.end()) {
     UMA_HISTOGRAM_COUNTS("Throttling.SiteOptedOut", 1);
 
-    net_log_->EndEvent(
+    net_log_.EndEvent(
         NetLog::TYPE_THROTTLING_DISABLED_FOR_HOST,
         make_scoped_refptr(new NetLogStringParameter("host", host)));
     opt_out_hosts_.insert(host);
   }
 }
 
 void URLRequestThrottlerManager::OverrideEntryForTests(
     const GURL& url,
     URLRequestThrottlerEntry* entry) {
   // Normalize the url.
@@ skipping 22 matching lines @@
 void URLRequestThrottlerManager::set_enforce_throttling(bool enforce) {
   enforce_throttling_ = enforce;
 }
 
 bool URLRequestThrottlerManager::enforce_throttling() {
   return enforce_throttling_;
 }
 
 void URLRequestThrottlerManager::set_net_log(NetLog* net_log) {
   DCHECK(net_log);
-  NetLog::Source source(NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING,
-                        net_log->NextID());
-  net_log_.reset(new BoundNetLog(source, net_log));
+  net_log_ = BoundNetLog::Make(net_log,
+                               NetLog::SOURCE_EXPONENTIAL_BACKOFF_THROTTLING);
 }
 
 NetLog* URLRequestThrottlerManager::net_log() const {
-  return net_log_->net_log();
+  return net_log_.net_log();
 }
 
 void URLRequestThrottlerManager::OnIPAddressChanged() {
   OnNetworkChange();
 }
 
 void URLRequestThrottlerManager::OnOnlineStateChanged(bool online) {
   OnNetworkChange();
 }
 
 // TODO(joi): Turn throttling on by default when appropriate.
 URLRequestThrottlerManager::URLRequestThrottlerManager()
     : requests_since_last_gc_(0),
       enforce_throttling_(false),
       enable_thread_checks_(false),
       logged_for_localhost_disabled_(false),
       registered_from_thread_(base::kInvalidThreadId) {
   // Construction/destruction is on main thread (because BrowserMain
   // retrieves an instance to call InitializeOptions), but is from then on
   // used on I/O thread.
   DetachFromThread();
 
   url_id_replacements_.ClearPassword();
   url_id_replacements_.ClearUsername();
   url_id_replacements_.ClearQuery();
   url_id_replacements_.ClearRef();
-
-  // Make sure there is always a net_log_ instance, even if it logs to
-  // nowhere.
-  net_log_.reset(new BoundNetLog());
 }
 
 URLRequestThrottlerManager::~URLRequestThrottlerManager() {
   // Destruction is on main thread (AtExit), but real use is on I/O thread.
   // The AtExit manager does not run until the I/O thread has finished
   // processing.
   DetachFromThread();
 
   // We must currently skip this in the production case, where the destructor
   // does not run on the thread we registered from.
@@ skipping 55 matching lines @@
 void URLRequestThrottlerManager::OnNetworkChange() {
   // Remove all entries.  Any entries that in-flight requests have a reference
   // to will live until those requests end, and these entries may be
   // inconsistent with new entries for the same URLs, but since what we
   // want is a clean slate for the new connection state, this is OK.
   url_entries_.clear();
   requests_since_last_gc_ = 0;
 }
 
 }  // namespace net