net: rename BoundNetLog to NetLogWithSource

components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.cc

 // Copyright 2015 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 "components/data_reduction_proxy/core/common/data_reduction_proxy_event_creator.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 174 matching lines @@
 void DataReductionProxyEventCreator::AddProxyDisabledEvent(
     net::NetLog* net_log) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&DisableDataReductionProxyCallback);
   PostEnabledEvent(net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_ENABLED,
                    false, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::AddBypassActionEvent(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     DataReductionProxyBypassAction bypass_action,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     const base::TimeDelta& bypass_duration) {
   DCHECK(thread_checker_.CalledOnValidThread());
   int64_t expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&UrlBypassActionCallback, bypass_action, request_method, url,
                  should_retry, bypass_duration.InSeconds(), expiration_ticks);
-  PostBoundNetLogBypassEvent(
+  PostNetLogWithSourceBypassEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
       net::NetLogEventPhase::NONE, expiration_ticks, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::AddBypassTypeEvent(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     DataReductionProxyBypassType bypass_type,
     const std::string& request_method,
     const GURL& url,
     bool should_retry,
     const base::TimeDelta& bypass_duration) {
   DCHECK(thread_checker_.CalledOnValidThread());
   int64_t expiration_ticks = GetExpirationTicks(bypass_duration.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&UrlBypassTypeCallback, bypass_type, request_method, url,
                  should_retry, bypass_duration.InSeconds(), expiration_ticks);
-  PostBoundNetLogBypassEvent(
+  PostNetLogWithSourceBypassEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
       net::NetLogEventPhase::NONE, expiration_ticks, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::AddProxyFallbackEvent(
     net::NetLog* net_log,
     const std::string& proxy_url,
     int net_error) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const net::NetLog::ParametersCallback& parameters_callback =
       base::Bind(&FallbackCallback, proxy_url, net_error);
   PostEvent(net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_FALLBACK,
             parameters_callback);
 }
 
 void DataReductionProxyEventCreator::BeginSecureProxyCheck(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     const GURL& url) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // This callback must be invoked synchronously
   const net::NetLog::ParametersCallback& parameters_callback =
       net::NetLog::StringCallback("url", &url.spec());
-  PostBoundNetLogSecureProxyCheckEvent(
+  PostNetLogWithSourceSecureProxyCheckEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_CANARY_REQUEST,
       net::NetLogEventPhase::BEGIN,
       DataReductionProxyEventStorageDelegate::CHECK_PENDING,
       parameters_callback);
 }
 
 void DataReductionProxyEventCreator::EndSecureProxyCheck(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     int net_error,
     int http_response_code,
     bool succeeded) {
   DCHECK(thread_checker_.CalledOnValidThread());
   const net::NetLog::ParametersCallback& parameters_callback = base::Bind(
       &EndCanaryRequestCallback, net_error, http_response_code, succeeded);
-  PostBoundNetLogSecureProxyCheckEvent(
+  PostNetLogWithSourceSecureProxyCheckEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_CANARY_REQUEST,
       net::NetLogEventPhase::END,
       succeeded ? DataReductionProxyEventStorageDelegate::CHECK_SUCCESS
                 : DataReductionProxyEventStorageDelegate::CHECK_FAILED,
       parameters_callback);
 }
 
 void DataReductionProxyEventCreator::BeginConfigRequest(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     const GURL& url) {
   // This callback must be invoked synchronously.
   const net::NetLog::ParametersCallback& parameters_callback =
       net::NetLog::StringCallback("url", &url.spec());
-  PostBoundNetLogConfigRequestEvent(
+  PostNetLogWithSourceConfigRequestEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_CONFIG_REQUEST,
       net::NetLogEventPhase::BEGIN, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::EndConfigRequest(
-    const net::BoundNetLog& net_log,
+    const net::NetLogWithSource& net_log,
     int net_error,
     int http_response_code,
     int failure_count,
     const std::vector<net::ProxyServer>& proxies_for_http,
     const base::TimeDelta& refresh_duration,
     const base::TimeDelta& retry_delay) {
   int64_t refresh_duration_minutes = refresh_duration.InMinutes();
   int64_t expiration_ticks = GetExpirationTicks(retry_delay.InSeconds());
   const net::NetLog::ParametersCallback& parameters_callback = base::Bind(
       &EndConfigRequestCallback, net_error, http_response_code, failure_count,
       proxies_for_http, refresh_duration_minutes, expiration_ticks);
-  PostBoundNetLogConfigRequestEvent(
+  PostNetLogWithSourceConfigRequestEvent(
       net_log, net::NetLogEventType::DATA_REDUCTION_PROXY_CONFIG_REQUEST,
       net::NetLogEventPhase::END, parameters_callback);
 }
 
 void DataReductionProxyEventCreator::PostEvent(
     net::NetLog* net_log,
     net::NetLogEventType type,
     const net::NetLog::ParametersCallback& callback) {
   std::unique_ptr<base::Value> event = BuildDataReductionProxyEvent(
       type, net::NetLog::Source(), net::NetLogEventPhase::NONE, callback);
@@ skipping 11 matching lines @@
     const net::NetLog::ParametersCallback& callback) {
   std::unique_ptr<base::Value> event = BuildDataReductionProxyEvent(
       type, net::NetLog::Source(), net::NetLogEventPhase::NONE, callback);
   if (event)
     storage_delegate_->AddEnabledEvent(std::move(event), enabled);
 
   if (net_log)
     net_log->AddGlobalEntry(type, callback);
 }
 
-void DataReductionProxyEventCreator::PostBoundNetLogBypassEvent(
-    const net::BoundNetLog& net_log,
+void DataReductionProxyEventCreator::PostNetLogWithSourceBypassEvent(
+    const net::NetLogWithSource& net_log,
     net::NetLogEventType type,
     net::NetLogEventPhase phase,
     int64_t expiration_ticks,
     const net::NetLog::ParametersCallback& callback) {
   std::unique_ptr<base::Value> event =
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback);
   if (event)
     storage_delegate_->AddAndSetLastBypassEvent(std::move(event),
                                                 expiration_ticks);
   net_log.AddEntry(type, phase, callback);
 }
 
-void DataReductionProxyEventCreator::PostBoundNetLogSecureProxyCheckEvent(
-    const net::BoundNetLog& net_log,
+void DataReductionProxyEventCreator::PostNetLogWithSourceSecureProxyCheckEvent(
+    const net::NetLogWithSource& net_log,
     net::NetLogEventType type,
     net::NetLogEventPhase phase,
     DataReductionProxyEventStorageDelegate::SecureProxyCheckState state,
     const net::NetLog::ParametersCallback& callback) {
   std::unique_ptr<base::Value> event(
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback));
   if (event)
     storage_delegate_->AddEventAndSecureProxyCheckState(std::move(event),
                                                         state);
   net_log.AddEntry(type, phase, callback);
 }
 
-void DataReductionProxyEventCreator::PostBoundNetLogConfigRequestEvent(
-    const net::BoundNetLog& net_log,
+void DataReductionProxyEventCreator::PostNetLogWithSourceConfigRequestEvent(
+    const net::NetLogWithSource& net_log,
     net::NetLogEventType type,
     net::NetLogEventPhase phase,
     const net::NetLog::ParametersCallback& callback) {
   std::unique_ptr<base::Value> event(
       BuildDataReductionProxyEvent(type, net_log.source(), phase, callback));
   if (event) {
     storage_delegate_->AddEvent(std::move(event));
     net_log.AddEntry(type, phase, callback);
   }
 }
 
 }  // namespace data_reduction_proxy