net: rename BoundNetLog to NetLogWithSource

components/data_reduction_proxy/core/common/data_reduction_proxy_event_store_unittest.cc

 // Copyright 2014 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_store.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
@@ skipping 17 matching lines @@
 #include "net/log/test_net_log.h"
 #include "net/log/test_net_log_entry.h"
 #include "net/proxy/proxy_server.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace data_reduction_proxy {
 
 class DataReductionProxyEventStoreTest : public testing::Test {
  public:
   DataReductionProxyEventStoreTest() : net_log_(new net::TestNetLog()) {
-    bound_net_log_ = net::BoundNetLog::Make(
+    net_log_with_source_ = net::NetLogWithSource::Make(
         net_log_.get(), net::NetLogSourceType::DATA_REDUCTION_PROXY);
   }
 
   void SetUp() override {
     event_store_.reset(new DataReductionProxyEventStore());
     event_creator_.reset(
         new DataReductionProxyEventCreator(event_store_.get()));
   }
 
   net::TestNetLogEntry GetSingleEntry() const {
@@ skipping 10 matching lines @@
   }
 
   DataReductionProxyEventStore* event_store() { return event_store_.get(); }
 
   DataReductionProxyEventCreator* event_creator() {
     return event_creator_.get();
   }
 
   net::TestNetLog* net_log() { return net_log_.get(); }
 
-  const net::BoundNetLog& bound_net_log() {
-    return bound_net_log_;
+  const net::NetLogWithSource& net_log_with_source() {
+    return net_log_with_source_;
   }
 
   size_t event_count() const { return event_store_->stored_events_.size(); }
 
   DataReductionProxyEventStorageDelegate::SecureProxyCheckState
   secure_proxy_check_state() const {
     return event_store_->secure_proxy_check_state_;
   }
 
   base::Value* last_bypass_event() const {
     return event_store_->last_bypass_event_.get();
   }
 
  private:
   std::unique_ptr<net::TestNetLog> net_log_;
   std::unique_ptr<DataReductionProxyEventStore> event_store_;
   std::unique_ptr<DataReductionProxyEventCreator> event_creator_;
-  net::BoundNetLog bound_net_log_;
+  net::NetLogWithSource net_log_with_source_;
 };
 
 TEST_F(DataReductionProxyEventStoreTest, TestAddProxyEnabledEvent) {
   EXPECT_EQ(0u, event_count());
   std::vector<net::ProxyServer> proxies_for_http;
   event_creator()->AddProxyEnabledEvent(net_log(), false, proxies_for_http);
   EXPECT_EQ(1u, event_count());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_ENABLED, entry.type);
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestAddProxyDisabledEvent) {
   EXPECT_EQ(0u, event_count());
   event_creator()->AddProxyDisabledEvent(net_log());
   EXPECT_EQ(1u, event_count());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_ENABLED, entry.type);
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestAddBypassActionEvent) {
   EXPECT_EQ(0u, event_count());
   EXPECT_EQ(nullptr, last_bypass_event());
   event_creator()->AddBypassActionEvent(
-      bound_net_log(), BYPASS_ACTION_TYPE_BYPASS, "GET", GURL(), false,
+      net_log_with_source(), BYPASS_ACTION_TYPE_BYPASS, "GET", GURL(), false,
       base::TimeDelta::FromMinutes(1));
   EXPECT_EQ(1u, event_count());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
             entry.type);
   EXPECT_NE(nullptr, last_bypass_event());
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestAddBypassTypeEvent) {
   EXPECT_EQ(0u, event_count());
   EXPECT_EQ(nullptr, last_bypass_event());
-  event_creator()->AddBypassTypeEvent(bound_net_log(), BYPASS_EVENT_TYPE_LONG,
-                                      "GET", GURL(), false,
-                                      base::TimeDelta::FromMinutes(1));
+  event_creator()->AddBypassTypeEvent(net_log_with_source(),
+                                      BYPASS_EVENT_TYPE_LONG, "GET", GURL(),
+                                      false, base::TimeDelta::FromMinutes(1));
   EXPECT_EQ(1u, event_count());
   EXPECT_EQ(1u, net_log()->GetSize());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_BYPASS_REQUESTED,
             entry.type);
   EXPECT_NE(nullptr, last_bypass_event());
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestAddProxyFallbackEvent) {
   EXPECT_EQ(0u, event_count());
   event_creator()->AddProxyFallbackEvent(net_log(), "bad_proxy",
                                          net::ERR_PROXY_CONNECTION_FAILED);
   EXPECT_EQ(1u, event_count());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_FALLBACK, entry.type);
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestBeginSecureProxyCheck) {
   EXPECT_EQ(0u, event_count());
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_UNKNOWN,
             secure_proxy_check_state());
-  event_creator()->BeginSecureProxyCheck(bound_net_log(), GURL());
+  event_creator()->BeginSecureProxyCheck(net_log_with_source(), GURL());
   EXPECT_EQ(1u, event_count());
   EXPECT_EQ(1u, net_log()->GetSize());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_CANARY_REQUEST,
             entry.type);
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_PENDING,
             secure_proxy_check_state());
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestEndSecureProxyCheck) {
   EXPECT_EQ(0u, event_count());
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_UNKNOWN,
             secure_proxy_check_state());
-  event_creator()->EndSecureProxyCheck(bound_net_log(), 0, net::HTTP_OK, true);
+  event_creator()->EndSecureProxyCheck(net_log_with_source(), 0, net::HTTP_OK,
+                                       true);
   EXPECT_EQ(1u, event_count());
   EXPECT_EQ(1u, net_log()->GetSize());
   net::TestNetLogEntry entry = GetSingleEntry();
   EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_CANARY_REQUEST,
             entry.type);
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_SUCCESS,
             secure_proxy_check_state());
 }
 
 TEST_F(DataReductionProxyEventStoreTest, TestEndSecureProxyCheckFailed) {
@@ skipping 16 matching lines @@
       {
        "Bad content", net::OK, net::HTTP_OK, false, false,
       },
   };
   size_t expected_event_count = 0;
   EXPECT_EQ(expected_event_count, net_log()->GetSize());
   EXPECT_EQ(expected_event_count++, event_count());
   EXPECT_EQ(DataReductionProxyEventStorageDelegate::CHECK_UNKNOWN,
             secure_proxy_check_state());
   for (const auto& test : tests) {
-    event_creator()->EndSecureProxyCheck(bound_net_log(), test.net_error,
+    event_creator()->EndSecureProxyCheck(net_log_with_source(), test.net_error,
                                          test.http_response_code,
                                          test.secure_proxy_check_succeeded);
     EXPECT_EQ(expected_event_count, net_log()->GetSize()) << test.test_case;
     EXPECT_EQ(expected_event_count++, event_count()) << test.test_case;
     net::TestNetLogEntry entry = GetLatestEntry();
     EXPECT_EQ(net::NetLogEventType::DATA_REDUCTION_PROXY_CANARY_REQUEST,
               entry.type)
         << test.test_case;
     EXPECT_EQ(test.secure_proxy_check_succeeded
                   ? DataReductionProxyEventStorageDelegate::CHECK_SUCCESS
@@ skipping 81 matching lines @@
   sanitized_event->SetString("method", "GET");
 
   bypass_event->Set("params", std::move(bypass_params));
   std::string sanitized_output;
   base::JSONWriter::Write(*sanitized_event.get(), &sanitized_output);
   event_store()->AddAndSetLastBypassEvent(std::move(bypass_event), 0);
   EXPECT_EQ(sanitized_output, event_store()->SanitizedLastBypassEvent());
 }
 
 }  // namespace data_reduction_proxy