net: rename BoundNetLog to NetLogWithSource

net/sdch/sdch_owner_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 "net/sdch/sdch_owner.h"
 
 #include <utility>
 
 #include "base/location.h"
 #include "base/macros.h"
@@ skipping 246 matching lines @@
     for (std::vector<PendingRequest>::iterator it = requests_.begin();
          it != requests_.end(); ++it) {
       if (it->url_ == dictionary_url)
         return true;
     }
     return false;
   }
 
   bool CompletePendingRequest(const GURL& dictionary_url,
                               const std::string& dictionary_text,
-                              const BoundNetLog& net_log,
+                              const NetLogWithSource& net_log,
                               bool was_from_cache) {
     for (std::vector<PendingRequest>::iterator it = requests_.begin();
          it != requests_.end(); ++it) {
       if (it->url_ == dictionary_url) {
         it->callback_.Run(dictionary_text, dictionary_url, net_log,
                           was_from_cache);
         requests_.erase(it);
         return true;
       }
     }
@@ skipping 39 matching lines @@
     // which leaves the test in control of signals to SdchOwner.
     url_request_context_.set_job_factory(&job_factory_);
 
     // Reduce sizes to reduce time for string operations.
     sdch_owner_->SetMaxTotalDictionarySize(kMaxSizeForTesting);
     sdch_owner_->SetMinSpaceForDictionaryFetch(kMinFetchSpaceForTesting);
   }
 
   SdchManager& sdch_manager() { return sdch_manager_; }
   SdchOwner& sdch_owner() { return *(sdch_owner_.get()); }
-  BoundNetLog& bound_net_log() { return net_log_; }
+  NetLogWithSource& net_log() { return net_log_; }
 
   int JobsRecentlyCreated() {
     int result = error_jobs_created - last_jobs_created_;
     last_jobs_created_ = error_jobs_created;
     return result;
   }
 
   bool DictionaryPresentInManager(const std::string& server_hash) {
     // Presumes all tests use generic url.
     SdchProblemCode tmp;
@@ skipping 52 matching lines @@
     return CreateAndAddDictionary(size, last_used_time, base::Time(),
                                   server_hash_p);
   }
 
   void ResetOwner() {
     sdch_owner_.reset(new SdchOwner(&sdch_manager_, &url_request_context_));
   }
 
  private:
   int last_jobs_created_;
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   int dictionary_creation_index_;
 
   // The dependencies of these objects (sdch_owner_ -> {sdch_manager_,
   // url_request_context_}, url_request_context_->job_factory_) require
   // this order for correct destruction semantics.
   MockURLRequestJobFactory job_factory_;
   URLRequestContext url_request_context_;
   SdchManager sdch_manager_;
   std::unique_ptr<SdchOwner> sdch_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(SdchOwnerTest);
 };
 
 // Does OnGetDictionary result in a fetch when there's enough space, and not
 // when there's not?
 TEST_F(SdchOwnerTest, OnGetDictionary_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
 
   // Fetch generated when empty.
   GURL dict_url1(std::string(generic_url) + "/d1");
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url1);
   EXPECT_EQ(1, JobsRecentlyCreated());
 
   // Fetch generated when half full.
   GURL dict_url2(std::string(generic_url) + "/d2");
   std::string dictionary1(NewSdchDictionary(kMaxSizeForTesting / 2));
   sdch_owner().OnDictionaryFetched(base::Time::Now(), base::Time::Now(), 1,
-                                   dictionary1, dict_url1, bound_net_log(),
-                                   false);
+                                   dictionary1, dict_url1, net_log(), false);
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url2);
   EXPECT_EQ(1, JobsRecentlyCreated());
 
   // Fetch not generated when close to completely full.
   GURL dict_url3(std::string(generic_url) + "/d3");
   std::string dictionary2(NewSdchDictionary(
       (kMaxSizeForTesting / 2 - kMinFetchSpaceForTesting / 2)));
   sdch_owner().OnDictionaryFetched(base::Time::Now(), base::Time::Now(), 1,
-                                   dictionary2, dict_url2, bound_net_log(),
-                                   false);
+                                   dictionary2, dict_url2, net_log(), false);
   EXPECT_EQ(0, JobsRecentlyCreated());
   SignalGetDictionaryAndClearJobs(request_url, dict_url3);
   EXPECT_EQ(0, JobsRecentlyCreated());
 }
 
 // Make sure attempts to add dictionaries do what they should.
 TEST_F(SdchOwnerTest, OnDictionaryFetched_Fetching) {
   GURL request_url(std::string(generic_url) + "/r1");
   std::string client_hash;
   std::string server_hash;
@@ skipping 383 matching lines @@
     std::string dict;
     dict.append("Domain: ");
     dict.append(url.host());
     dict.append("\n\n");
     dict.append(url.spec());
     dict.append(nonce);
     return dict;
   }
 
  protected:
-  BoundNetLog net_log_;
+  NetLogWithSource net_log_;
   std::unique_ptr<SdchManager> manager_;
   MockSdchDictionaryFetcher* fetcher_;
   std::unique_ptr<SdchOwner> owner_;
   TestURLRequestContext url_request_context_;
 };
 
 // Test an empty persistence store.
 TEST_F(SdchOwnerPersistenceTest, Empty) {
   ResetOwner(base::WrapUnique(new TestPrefStorage(true)));
   EXPECT_EQ(0, owner_->GetDictionaryCountForTesting());
@@ skipping 157 matching lines @@
 
   EXPECT_TRUE(CompleteLoadFromURL(url0, "0", true));
   EXPECT_TRUE(CompleteLoadFromURL(url1, "1", false));
 
   tester.ExpectTotalCount("Sdch3.NetworkBytesSpent", 1);
   tester.ExpectUniqueSample("Sdch3.NetworkBytesSpent",
                             CreateDictionary(url1, "1").size(), 1);
 }
 
 }  // namespace net