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,8 +69,8 @@ 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,
-                                base::Unretained(this)));
+  cache->Find("foo", base::BindOnce(&PpdCacheTest::CaptureFindResult,
+                                    base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 1);
   EXPECT_FALSE(find_result_.success);
@@ -82,8 +82,8 @@ TEST_F(PpdCacheTest, MissThenHit) {
   const char kTestKey2[] = "A different key";
   const char kTestContents[] = "Like, totally awesome contents";
 
-  cache->Find(kTestKey, base::Bind(&PpdCacheTest::CaptureFindResult,
-                                   base::Unretained(this)));
+  cache->Find(kTestKey, base::BindOnce(&PpdCacheTest::CaptureFindResult,
+                                       base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 1);
   EXPECT_FALSE(find_result_.success);
@@ -92,16 +92,16 @@ TEST_F(PpdCacheTest, MissThenHit) {
 
   scoped_task_environment_.RunUntilIdle();
 
-  cache->Find(kTestKey, base::Bind(&PpdCacheTest::CaptureFindResult,
-                                   base::Unretained(this)));
+  cache->Find(kTestKey, base::BindOnce(&PpdCacheTest::CaptureFindResult,
+                                       base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 2);
   EXPECT_TRUE(find_result_.success);
   EXPECT_EQ(find_result_.contents, kTestContents);
   EXPECT_LT(find_result_.age, base::TimeDelta::FromMinutes(5));
 
-  cache->Find(kTestKey2, base::Bind(&PpdCacheTest::CaptureFindResult,
-                                    base::Unretained(this)));
+  cache->Find(kTestKey2, base::BindOnce(&PpdCacheTest::CaptureFindResult,
+                                        base::Unretained(this)));
   scoped_task_environment_.RunUntilIdle();
   EXPECT_EQ(captured_find_results_, 3);
   EXPECT_FALSE(find_result_.success);

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,15 +136,16 @@ 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,
-                          const std::string& manufacturer,
-                          const std::string& model)>;
+      base::OnceCallback<void(CallbackResultCode,
+                              const std::string& manufacturer,
+                              const std::string& model)>;
 
   // Create and return a new PpdProvider with the given cache and options.
   // A references to |url_context_getter| is taken.
@@ -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.