Bind API change

We've moved from using Bind to BindOnce and BindRepeating. This
implements that change in chromeos/printing.

BUG=chromium:804035
TEST=passes unit tests

Change-Id: Icaf15b00252398c9685a0482e114e7fef7ddea74
Reviewed-on: https://chromium-review.googlesource.com/884825
Commit-Queue: Luum Habtemariam <luum@chromium.org>
Reviewed-by: Sean Kau <skau@chromium.org>
Cr-Commit-Position: refs/heads/master@{#531995}

chrome/browser/chromeos/printing/cups_printers_manager_unittest.cc

@@ -205,27 +205,27 @@ class FakePpdProvider : public PpdProvider {
   FakePpdProvider() {}
 
   void ResolvePpdReference(const PrinterSearchData& search_data,
-                           const ResolvePpdReferenceCallback& cb) override {
+                           ResolvePpdReferenceCallback cb) override {
     if (search_data.make_and_model.empty()) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(cb, PpdProvider::NOT_FOUND, Printer::PpdReference()));
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::NOT_FOUND,
+                                    Printer::PpdReference()));
     } else {
       Printer::PpdReference ret;
       ret.effective_make_and_model = search_data.make_and_model[0];
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, ret));
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::SUCCESS, ret));
     }
   }
 
   // These three functions are not used by CupsPrintersManager.
   void ResolvePpd(const Printer::PpdReference& reference,
                   ResolvePpdCallback cb) override {}
-  void ResolveManufacturers(const ResolveManufacturersCallback& cb) override {}
+  void ResolveManufacturers(ResolveManufacturersCallback cb) override {}
   void ResolvePrinters(const std::string& manufacturer,
-                       const ResolvePrintersCallback& cb) override {}
+                       ResolvePrintersCallback cb) override {}
   void ReverseLookup(const std::string& effective_make_and_model,
-                     const ReverseLookupCallback& cb) override {}
+                     ReverseLookupCallback cb) override {}
 
  private:
   ~FakePpdProvider() override {}

chromeos/printing/ppd_cache.cc

@@ -156,7 +156,8 @@ class PpdCacheImpl : public PpdCache {
                        const std::string& contents,
                        base::TimeDelta age) override {
     store_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&StoreImpl, cache_base_dir_, key, contents, age));
+        FROM_HERE,
+        base::BindOnce(&StoreImpl, cache_base_dir_, key, contents, age));
   }
 
  private:

chromeos/printing/ppd_cache_unittest.cc

@@ -69,7 +69,7 @@ class PpdCacheTest : public ::testing::Test {
 // Test that we miss on an empty cache.
 TEST_F(PpdCacheTest, SimpleMiss) {
   auto cache = CreateTestCache();
-  cache->Find("foo", base::Bind(&PpdCacheTest::CaptureFindResult,
+  cache->Find("foo", base::BindOnce(&PpdCacheTest::CaptureFindResult,
                                     base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 1);
@@ -82,7 +82,7 @@ TEST_F(PpdCacheTest, MissThenHit) {
   const char kTestKey2[] = "A different key";
   const char kTestContents[] = "Like, totally awesome contents";
 
-  cache->Find(kTestKey, base::Bind(&PpdCacheTest::CaptureFindResult,
+  cache->Find(kTestKey, base::BindOnce(&PpdCacheTest::CaptureFindResult,
                                        base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 1);
@@ -92,7 +92,7 @@ TEST_F(PpdCacheTest, MissThenHit) {
 
   scoped_task_environment_.RunUntilIdle();
 
-  cache->Find(kTestKey, base::Bind(&PpdCacheTest::CaptureFindResult,
+  cache->Find(kTestKey, base::BindOnce(&PpdCacheTest::CaptureFindResult,
                                        base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 2);
@@ -100,7 +100,7 @@ TEST_F(PpdCacheTest, MissThenHit) {
   EXPECT_EQ(find_result_.contents, kTestContents);
   EXPECT_LT(find_result_.age, base::TimeDelta::FromMinutes(5));
 
-  cache->Find(kTestKey2, base::Bind(&PpdCacheTest::CaptureFindResult,
+  cache->Find(kTestKey2, base::BindOnce(&PpdCacheTest::CaptureFindResult,
                                         base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 3);

chromeos/printing/ppd_provider.cc

@@ -350,18 +350,18 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
   //
   // This means when a request comes in, we either queue it and start background
   // fetches if necessary, or we satisfy it immediately from memory.
-  void ResolveManufacturers(const ResolveManufacturersCallback& cb) override {
+  void ResolveManufacturers(ResolveManufacturersCallback cb) override {
     CHECK(base::SequencedTaskRunnerHandle::IsSet())
         << "ResolveManufacturers must be called from a SequencedTaskRunner"
            "context";
     if (cached_metadata_.get() != nullptr) {
       // We already have this in memory.
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(cb, PpdProvider::SUCCESS, GetManufacturerList()));
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::SUCCESS,
+                                    GetManufacturerList()));
       return;
     }
-    manufacturers_resolution_queue_.push_back(cb);
+    manufacturers_resolution_queue_.push_back(std::move(cb));
     MaybeStartFetch();
   }
 
@@ -370,13 +370,12 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
   // started.
   bool MaybeStartNextPpdReferenceResolution() {
     while (!ppd_reference_resolution_queue_.empty()) {
-      const PrinterSearchData& next =
-          ppd_reference_resolution_queue_.front().first;
+      auto& next = ppd_reference_resolution_queue_.front();
       // Have we successfully resolved next yet?
       bool resolved_next = false;
-      if (!next.make_and_model.empty()) {
+      if (!next.first.make_and_model.empty()) {
         // Check the index for each make-and-model guess.
-        for (const std::string& make_and_model : next.make_and_model) {
+        for (const std::string& make_and_model : next.first.make_and_model) {
           // Check if we need to load its ppd_index
           int ppd_index_shard = IndexShard(make_and_model);
           if (!base::ContainsKey(cached_ppd_idxs_, ppd_index_shard)) {
@@ -389,8 +388,7 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
             Printer::PpdReference ret;
             ret.effective_make_and_model = make_and_model;
             base::SequencedTaskRunnerHandle::Get()->PostTask(
-                FROM_HERE,
-                base::Bind(ppd_reference_resolution_queue_.front().second,
+                FROM_HERE, base::BindOnce(std::move(next.second),
                                           PpdProvider::SUCCESS, ret));
             ppd_reference_resolution_queue_.pop_front();
             resolved_next = true;
@@ -403,15 +401,15 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
         // guesses for the front entry, or they all missed.  Try USB ids
         // instead.  This entry will be completed when the usb fetch
         // returns.
-        if (next.usb_vendor_id && next.usb_product_id) {
-          StartFetch(GetUsbURL(next.usb_vendor_id), FT_USB_DEVICES);
+        if (next.first.usb_vendor_id && next.first.usb_product_id) {
+          StartFetch(GetUsbURL(next.first.usb_vendor_id), FT_USB_DEVICES);
           return true;
         }
         // We don't have anything else left to try.  NOT_FOUND it is.
         base::SequencedTaskRunnerHandle::Get()->PostTask(
             FROM_HERE,
-            base::Bind(ppd_reference_resolution_queue_.front().second,
-                       PpdProvider::NOT_FOUND, Printer::PpdReference()));
+            base::BindOnce(std::move(next.second), PpdProvider::NOT_FOUND,
+                           Printer::PpdReference()));
         ppd_reference_resolution_queue_.pop_front();
       }
     }
@@ -491,7 +489,7 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
   }
 
   void ResolvePrinters(const std::string& manufacturer,
-                       const ResolvePrintersCallback& cb) override {
+                       ResolvePrintersCallback cb) override {
     std::unordered_map<std::string, ManufacturerMetadata>::iterator it;
     if (cached_metadata_.get() == nullptr ||
         (it = cached_metadata_->find(manufacturer)) ==
@@ -500,28 +498,28 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
       LOG(ERROR) << "Can't resolve printers for unknown manufacturer "
                  << manufacturer;
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE,
-          base::Bind(cb, PpdProvider::INTERNAL_ERROR, ResolvedPrintersList()));
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::INTERNAL_ERROR,
+                                    ResolvedPrintersList()));
       return;
     }
     if (it->second.printers.get() != nullptr) {
       // Satisfy from the cache.
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS,
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::SUCCESS,
                                     GetManufacturerPrinterList(it->second)));
     } else {
       // We haven't resolved this manufacturer yet.
       PrinterResolutionQueueEntry entry;
       entry.manufacturer = manufacturer;
       entry.url = GetPrintersURL(it->second.reference);
-      entry.cb = cb;
-      printers_resolution_queue_.push_back(entry);
+      entry.cb = std::move(cb);
+      printers_resolution_queue_.push_back(std::move(entry));
       MaybeStartFetch();
     }
   }
 
   void ResolvePpdReference(const PrinterSearchData& search_data,
-                           const ResolvePpdReferenceCallback& cb) override {
+                           ResolvePpdReferenceCallback cb) override {
     // In v2 metadata, we work with lowercased effective_make_and_models.
     PrinterSearchData lowercase_search_data(search_data);
     for (auto& make_and_model : search_data.make_and_model) {
@@ -529,7 +527,8 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
           base::ToLowerASCII(make_and_model));
     }
 
-    ppd_reference_resolution_queue_.push_back({lowercase_search_data, cb});
+    ppd_reference_resolution_queue_.push_back(
+        {lowercase_search_data, std::move(cb)});
     MaybeStartFetch();
   }
 
@@ -556,10 +555,10 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
   }
 
   void ReverseLookup(const std::string& effective_make_and_model,
-                     const ReverseLookupCallback& cb) override {
+                     ReverseLookupCallback cb) override {
     if (effective_make_and_model.empty()) {
       LOG(WARNING) << "Cannot resolve an empty make and model";
-      PostReverseLookupFailure(PpdProvider::NOT_FOUND, cb);
+      PostReverseLookupFailure(PpdProvider::NOT_FOUND, std::move(cb));
       return;
     }
 
@@ -570,8 +569,8 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
     ReverseIndexQueueEntry entry;
     entry.effective_make_and_model = lowercase_effective_make_and_model;
     entry.url = GetReverseIndexURL(lowercase_effective_make_and_model);
-    entry.cb = cb;
-    reverse_index_resolution_queue_.push_back(entry);
+    entry.cb = std::move(cb);
+    reverse_index_resolution_queue_.push_back(std::move(entry));
     MaybeStartFetch();
   }
 
@@ -690,8 +689,8 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
       std::string* content_ptr = file_contents.get();
       base::PostTaskAndReplyWithResult(
           disk_task_runner_.get(), FROM_HERE,
-          base::Bind(&FetchFile, url, content_ptr),
-          base::Bind(&PpdProviderImpl::OnFileFetchComplete, this,
+          base::BindOnce(&FetchFile, url, content_ptr),
+          base::BindOnce(&PpdProviderImpl::OnFileFetchComplete, this,
                          base::Passed(&file_contents)));
     }
   }
@@ -824,9 +823,10 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
 
     std::vector<std::string> manufacturer_list = GetManufacturerList();
     // Complete any queued manufacturer resolutions.
-    for (const auto& cb : manufacturers_resolution_queue_) {
+    for (auto& cb : manufacturers_resolution_queue_) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, PpdProvider::SUCCESS, manufacturer_list));
+          FROM_HERE, base::BindOnce(std::move(cb), PpdProvider::SUCCESS,
+                                    manufacturer_list));
     }
     manufacturers_resolution_queue_.clear();
   }
@@ -844,7 +844,8 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
 
     if (code != PpdProvider::SUCCESS) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(printers_resolution_queue_.front().cb, code,
+          FROM_HERE,
+          base::BindOnce(std::move(printers_resolution_queue_.front().cb), code,
                          ResolvedPrintersList()));
     } else {
       // This should be a list of lists of 2-element strings, where the first
@@ -870,7 +871,7 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
 
       base::SequencedTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
-          base::Bind(printers_resolution_queue_.front().cb,
+          base::BindOnce(std::move(printers_resolution_queue_.front().cb),
                          PpdProvider::SUCCESS,
                          GetManufacturerPrinterList(manufacturer_metadata)));
     }
@@ -936,12 +937,11 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
     std::vector<ReverseIndexJSON> contents;
     PpdProvider::CallbackResultCode code =
         ValidateAndParseReverseIndexJSON(&contents);
-    const ReverseIndexQueueEntry& entry =
-        reverse_index_resolution_queue_.front();
+    auto& entry = reverse_index_resolution_queue_.front();
 
     if (code != PpdProvider::SUCCESS) {
       LOG(ERROR) << "Request Failed or failed reverse index parsing";
-      PostReverseLookupFailure(code, entry.cb);
+      PostReverseLookupFailure(code, std::move(entry.cb));
     } else {
       auto found = std::find_if(contents.begin(), contents.end(),
                                 [&entry](const ReverseIndexJSON& rij) -> bool {
@@ -950,11 +950,11 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
                                 });
       if (found != contents.end()) {
         base::SequencedTaskRunnerHandle::Get()->PostTask(
-            FROM_HERE, base::Bind(entry.cb, PpdProvider::SUCCESS,
+            FROM_HERE, base::BindOnce(std::move(entry.cb), PpdProvider::SUCCESS,
                                       found->manufacturer, found->model));
       } else {
         LOG(ERROR) << "Failed to lookup printer in retrieved data response";
-        PostReverseLookupFailure(PpdProvider::NOT_FOUND, entry.cb);
+        PostReverseLookupFailure(PpdProvider::NOT_FOUND, std::move(entry.cb));
       }
     }
     reverse_index_resolution_queue_.pop_front();
@@ -1013,17 +1013,20 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
       ret.effective_make_and_model = contents;
     }
     base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(ppd_reference_resolution_queue_.front().second,
-                              result, ret));
+        FROM_HERE,
+        base::BindOnce(
+            std::move(ppd_reference_resolution_queue_.front().second), result,
+            ret));
     ppd_reference_resolution_queue_.pop_front();
   }
 
   // Something went wrong during metadata fetches.  Fail all queued metadata
   // resolutions with the given error code.
   void FailQueuedMetadataResolutions(PpdProvider::CallbackResultCode code) {
-    for (const auto& cb : manufacturers_resolution_queue_) {
+    for (auto& cb : manufacturers_resolution_queue_) {
       base::SequencedTaskRunnerHandle::Get()->PostTask(
-          FROM_HERE, base::Bind(cb, code, std::vector<std::string>()));
+          FROM_HERE,
+          base::BindOnce(std::move(cb), code, std::vector<std::string>()));
     }
     manufacturers_resolution_queue_.clear();
   }
@@ -1050,9 +1053,10 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
     // Everything in the PpdReference queue also depends on server information,
     // so should also be failed.
     auto task_runner = base::SequencedTaskRunnerHandle::Get();
-    for (const auto& entry : ppd_reference_resolution_queue_) {
+    for (auto& cb : ppd_reference_resolution_queue_) {
       task_runner->PostTask(
-          FROM_HERE, base::Bind(entry.second, code, Printer::PpdReference()));
+          FROM_HERE,
+          base::BindOnce(std::move(cb.second), code, Printer::PpdReference()));
     }
     ppd_reference_resolution_queue_.clear();
   }
@@ -1392,9 +1396,10 @@ class PpdProviderImpl : public PpdProvider, public net::URLFetcherDelegate {
   }
 
   void PostReverseLookupFailure(CallbackResultCode result,
-                                const ReverseLookupCallback& cb) {
+                                ReverseLookupCallback cb) {
     base::SequencedTaskRunnerHandle::Get()->PostTask(
-        FROM_HERE, base::Bind(cb, result, std::string(), std::string()));
+        FROM_HERE,
+        base::BindOnce(std::move(cb), result, std::string(), std::string()));
   }
 
   // The hash function to calculate the hash of canonical identifiers to the

chromeos/printing/ppd_provider.h

@@ -116,7 +116,8 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   // then the vector contains a sorted list of manufacturers for which we have
   // at least one printer driver.
   using ResolveManufacturersCallback =
-      base::Callback<void(CallbackResultCode, const std::vector<std::string>&)>;
+      base::OnceCallback<void(CallbackResultCode,
+                              const std::vector<std::string>&)>;
 
   // A list of printer names paired with the PpdReference that should be used
   // for that printer.
@@ -127,7 +128,7 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   // printer models from the given manufacturer for which we have a driver,
   // sorted by model_name.
   using ResolvePrintersCallback =
-      base::Callback<void(CallbackResultCode, const ResolvedPrintersList&)>;
+      base::OnceCallback<void(CallbackResultCode, const ResolvedPrintersList&)>;
 
   // Result of a ResolvePpdReference call.  If the result code is
   // SUCCESS, then the second argument contains the a PpdReference
@@ -135,13 +136,14 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   // the printer.  NOT_FOUND means we couldn't confidently figure out
   // a driver for the printer.
   using ResolvePpdReferenceCallback =
-      base::Callback<void(CallbackResultCode, const Printer::PpdReference&)>;
+      base::OnceCallback<void(CallbackResultCode,
+                              const Printer::PpdReference&)>;
 
   // Result of a ReverseLookup call.  If the result code is SUCCESS, then
   // |manufactuer| and |model| contain the strings that could have generated
   // the reference being looked up.
   using ReverseLookupCallback =
-      base::Callback<void(CallbackResultCode,
+      base::OnceCallback<void(CallbackResultCode,
                               const std::string& manufacturer,
                               const std::string& model)>;
 
@@ -158,7 +160,7 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   // localized in the default browser locale or the closest available fallback.
   //
   // |cb| will be called on the invoking thread, and will be sequenced.
-  virtual void ResolveManufacturers(const ResolveManufacturersCallback& cb) = 0;
+  virtual void ResolveManufacturers(ResolveManufacturersCallback cb) = 0;
 
   // Get all models from a given manufacturer, localized in the
   // default browser locale or the closest available fallback.
@@ -168,12 +170,12 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   //
   // |cb| will be called on the invoking thread, and will be sequenced.
   virtual void ResolvePrinters(const std::string& manufacturer,
-                               const ResolvePrintersCallback& cb) = 0;
+                               ResolvePrintersCallback cb) = 0;
 
   // Attempt to find a PpdReference for the given printer.  You should supply
   // as much information in search_data as you can.
   virtual void ResolvePpdReference(const PrinterSearchData& search_data,
-                                   const ResolvePpdReferenceCallback& cb) = 0;
+                                   ResolvePpdReferenceCallback cb) = 0;
 
   // Given a PpdReference, attempt to get the PPD for printing.
   //
@@ -184,7 +186,7 @@ class CHROMEOS_EXPORT PpdProvider : public base::RefCounted<PpdProvider> {
   // For a given PpdReference, retrieve the make and model strings used to
   // construct that reference.
   virtual void ReverseLookup(const std::string& effective_make_and_model,
-                             const ReverseLookupCallback& cb) = 0;
+                             ReverseLookupCallback cb) = 0;
 
   // Transform from ppd reference to ppd cache key.  This is exposed for
   // testing, and should not be used by other code.

chromeos/printing/ppd_provider_unittest.cc

@@ -267,7 +267,7 @@ class PpdProviderTest : public ::testing::Test {
                            const std::string& expected_used_locale) {
     captured_resolve_manufacturers_.clear();
     auto provider = CreateProvider(browser_locale, false);
-    provider->ResolveManufacturers(base::Bind(
+    provider->ResolveManufacturers(base::BindOnce(
         &PpdProviderTest::CaptureResolveManufacturers, base::Unretained(this)));
     scoped_task_environment_.RunUntilIdle();
     provider = nullptr;
@@ -330,9 +330,9 @@ TEST_F(PpdProviderTest, ManufacturersFetch) {
   StartFakePpdServer();
   auto provider = CreateProvider("en", false);
   // Issue two requests at the same time, both should be resolved properly.
-  provider->ResolveManufacturers(base::Bind(
+  provider->ResolveManufacturers(base::BindOnce(
       &PpdProviderTest::CaptureResolveManufacturers, base::Unretained(this)));
-  provider->ResolveManufacturers(base::Bind(
+  provider->ResolveManufacturers(base::BindOnce(
       &PpdProviderTest::CaptureResolveManufacturers, base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   ASSERT_EQ(2UL, captured_resolve_manufacturers_.size());
@@ -350,9 +350,9 @@ TEST_F(PpdProviderTest, ManufacturersFetch) {
 TEST_F(PpdProviderTest, ManufacturersFetchNoServer) {
   auto provider = CreateProvider("en", false);
   // Issue two requests at the same time, both should be resolved properly.
-  provider->ResolveManufacturers(base::Bind(
+  provider->ResolveManufacturers(base::BindOnce(
       &PpdProviderTest::CaptureResolveManufacturers, base::Unretained(this)));
-  provider->ResolveManufacturers(base::Bind(
+  provider->ResolveManufacturers(base::BindOnce(
       &PpdProviderTest::CaptureResolveManufacturers, base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   ASSERT_EQ(2UL, captured_resolve_manufacturers_.size());
@@ -392,14 +392,14 @@ TEST_F(PpdProviderTest, RepeatedMakeModel) {
   // Resolve the same thing repeatedly.
   provider->ResolvePpdReference(
       unrecognized_printer,
-      base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                      base::Unretained(this)));
   provider->ResolvePpdReference(
-      mixed, base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      mixed, base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                             base::Unretained(this)));
   provider->ResolvePpdReference(
       recognized_printer,
-      base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                      base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -426,20 +426,20 @@ TEST_F(PpdProviderTest, UsbResolution) {
   search_data.usb_vendor_id = 0x031f;
   search_data.usb_product_id = 1592;
   provider->ResolvePpdReference(
-      search_data, base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      search_data, base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                                   base::Unretained(this)));
   // Should get back "Some other canonical reference"
   search_data.usb_vendor_id = 0x031f;
   search_data.usb_product_id = 6535;
   provider->ResolvePpdReference(
-      search_data, base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      search_data, base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                                   base::Unretained(this)));
 
   // Extant vendor id, nonexistant device id, should get a NOT_FOUND
   search_data.usb_vendor_id = 0x031f;
   search_data.usb_product_id = 8162;
   provider->ResolvePpdReference(
-      search_data, base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      search_data, base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                                   base::Unretained(this)));
 
   // Nonexistant vendor id, should get a NOT_FOUND in the real world, but
@@ -449,7 +449,7 @@ TEST_F(PpdProviderTest, UsbResolution) {
   search_data.usb_vendor_id = 1234;
   search_data.usb_product_id = 1782;
   provider->ResolvePpdReference(
-      search_data, base::Bind(&PpdProviderTest::CaptureResolvePpdReference,
+      search_data, base::BindOnce(&PpdProviderTest::CaptureResolvePpdReference,
                                   base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -478,14 +478,16 @@ TEST_F(PpdProviderTest, ResolvePrinters) {
   // Grab the manufacturer list, but don't bother to save it, we know what
   // should be in it and we check that elsewhere.  We just need to run the
   // resolve to populate the internal PpdProvider structures.
-  provider->ResolveManufacturers(base::Bind(&ResolveManufacturersNop));
+  provider->ResolveManufacturers(base::BindOnce(&ResolveManufacturersNop));
   scoped_task_environment_.RunUntilIdle();
 
-  provider->ResolvePrinters("manufacturer_a_en",
-                            base::Bind(&PpdProviderTest::CaptureResolvePrinters,
+  provider->ResolvePrinters(
+      "manufacturer_a_en",
+      base::BindOnce(&PpdProviderTest::CaptureResolvePrinters,
                      base::Unretained(this)));
-  provider->ResolvePrinters("manufacturer_b_en",
-                            base::Bind(&PpdProviderTest::CaptureResolvePrinters,
+  provider->ResolvePrinters(
+      "manufacturer_b_en",
+      base::BindOnce(&PpdProviderTest::CaptureResolvePrinters,
                      base::Unretained(this)));
 
   scoped_task_environment_.RunUntilIdle();
@@ -518,11 +520,12 @@ TEST_F(PpdProviderTest, ResolvePrinters) {
 TEST_F(PpdProviderTest, ResolvePrintersBadReference) {
   StartFakePpdServer();
   auto provider = CreateProvider("en", false);
-  provider->ResolveManufacturers(base::Bind(&ResolveManufacturersNop));
+  provider->ResolveManufacturers(base::BindOnce(&ResolveManufacturersNop));
   scoped_task_environment_.RunUntilIdle();
 
-  provider->ResolvePrinters("bogus_doesnt_exist",
-                            base::Bind(&PpdProviderTest::CaptureResolvePrinters,
+  provider->ResolvePrinters(
+      "bogus_doesnt_exist",
+      base::BindOnce(&PpdProviderTest::CaptureResolvePrinters,
                      base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   ASSERT_EQ(1UL, captured_resolve_printers_.size());
@@ -533,16 +536,18 @@ TEST_F(PpdProviderTest, ResolvePrintersBadReference) {
 TEST_F(PpdProviderTest, ResolvePrintersNoServer) {
   StartFakePpdServer();
   auto provider = CreateProvider("en", false);
-  provider->ResolveManufacturers(base::Bind(&ResolveManufacturersNop));
+  provider->ResolveManufacturers(base::BindOnce(&ResolveManufacturersNop));
   scoped_task_environment_.RunUntilIdle();
 
   StopFakePpdServer();
 
-  provider->ResolvePrinters("manufacturer_a_en",
-                            base::Bind(&PpdProviderTest::CaptureResolvePrinters,
+  provider->ResolvePrinters(
+      "manufacturer_a_en",
+      base::BindOnce(&PpdProviderTest::CaptureResolvePrinters,
                      base::Unretained(this)));
-  provider->ResolvePrinters("manufacturer_b_en",
-                            base::Bind(&PpdProviderTest::CaptureResolvePrinters,
+  provider->ResolvePrinters(
+      "manufacturer_b_en",
+      base::BindOnce(&PpdProviderTest::CaptureResolvePrinters,
                      base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   ASSERT_EQ(2UL, captured_resolve_printers_.size());
@@ -556,10 +561,10 @@ TEST_F(PpdProviderTest, ResolveServerKeyPpd) {
   auto provider = CreateProvider("en", false);
   Printer::PpdReference ref;
   ref.effective_make_and_model = "printer_b_ref";
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   ref.effective_make_and_model = "printer_c_ref";
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -581,7 +586,7 @@ TEST_F(PpdProviderTest, ResolveUserSuppliedUrlPpdFromNetworkFails) {
   Printer::PpdReference ref;
   ref.user_supplied_ppd_url = base::StringPrintf(
       "https://%s/user_supplied_ppd_directory/user_supplied.ppd", kPpdServer);
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -608,7 +613,7 @@ TEST_F(PpdProviderTest, ResolveUserSuppliedUrlPpdFromFile) {
   Printer::PpdReference ref;
   ref.user_supplied_ppd_url =
       base::StringPrintf("file://%s", filename.MaybeAsASCII().c_str());
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -634,7 +639,8 @@ TEST_F(PpdProviderTest, ResolvedPpdsGetCached) {
 
     ref.user_supplied_ppd_url =
         base::StringPrintf("file://%s", filename.MaybeAsASCII().c_str());
-    provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+    provider->ResolvePpd(ref,
+                         base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                         base::Unretained(this)));
     scoped_task_environment_.RunUntilIdle();
 
@@ -653,7 +659,7 @@ TEST_F(PpdProviderTest, ResolvedPpdsGetCached) {
   provider = CreateProvider("en", false);
 
   // Re-resolve.
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -669,10 +675,10 @@ TEST_F(PpdProviderTest, ExtractPpdFilters) {
   auto provider = CreateProvider("en", false);
   Printer::PpdReference ref;
   ref.effective_make_and_model = "printer_a_ref";
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   ref.effective_make_and_model = "printer_b_ref";
-  provider->ResolvePpd(ref, base::Bind(&PpdProviderTest::CaptureResolvePpd,
+  provider->ResolvePpd(ref, base::BindOnce(&PpdProviderTest::CaptureResolvePpd,
                                            base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
 
@@ -703,7 +709,7 @@ TEST_F(PpdProviderTest, ReverseLookup) {
   auto provider = CreateProvider("en", false);
   std::string ref = "printer_a_ref";
   provider->ReverseLookup(ref,
-                          base::Bind(&PpdProviderTest::CaptureReverseLookup,
+                          base::BindOnce(&PpdProviderTest::CaptureReverseLookup,
                                          base::Unretained(this)));
   // TODO(skau): PpdProvider has a race condition that prevents running these
   // requests in parallel.
@@ -711,7 +717,7 @@ TEST_F(PpdProviderTest, ReverseLookup) {
 
   std::string ref_fail = "printer_does_not_exist";
   provider->ReverseLookup(ref_fail,
-                          base::Bind(&PpdProviderTest::CaptureReverseLookup,
+                          base::BindOnce(&PpdProviderTest::CaptureReverseLookup,
                                          base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();