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& bound_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_;
 
@@ skipping 424 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