Add onGetUsbPrinterInfoRequested event to printerProvider API.

chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc

Index: chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc
diff --git a/chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc b/chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc
index d598cc975905ea5c2552c2d3cc12eeb95123e0a3..e6070cbbb5b40a170a57e024be8821d144e4a2c6 100644
--- a/chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc
+++ b/chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.cc
@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include <queue>
 #include <string>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
@@ -180,6 +180,15 @@ void RecordListValue(scoped_ptr<base::ListValue>* list_value_out,
   callback.Run();
 }
 
+// Used as a callback to StartGrantUsbPrinterAccess in tests.
+// Increases |*call_count| and records the value returned.
+void RecordPrinterInfo(size_t* call_count,
+                       scoped_ptr<base::DictionaryValue>* printer_info_out,
+                       const base::DictionaryValue& printer_info) {
+  ++(*call_count);
+  printer_info_out->reset(printer_info.DeepCopy());
+}
+
 // Converts JSON string to base::ListValue object.
 // On failure, returns NULL and fills |*error| string.
 scoped_ptr<base::ListValue> GetJSONAsListValue(const std::string& json,
@@ -298,13 +307,13 @@ class FakePrinterProviderAPI : public PrinterProviderAPI {
 
   void DispatchGetPrintersRequested(
       const PrinterProviderAPI::GetPrintersCallback& callback) override {
-    pending_printers_callbacks_.push_back(callback);
+    pending_printers_callbacks_.push(callback);
   }
 
   void DispatchGetCapabilityRequested(
       const std::string& destination_id,
       const PrinterProviderAPI::GetCapabilityCallback& callback) override {
-    pending_capability_callbacks_.push_back(base::Bind(callback));
+    pending_capability_callbacks_.push(callback);
   }
 
   void DispatchPrintRequested(
@@ -314,7 +323,16 @@ class FakePrinterProviderAPI : public PrinterProviderAPI {
     request_info.callback = callback;
     request_info.job = job;
 
-    pending_print_requests_.push_back(request_info);
+    pending_print_requests_.push(request_info);
+  }
+
+  void DispatchGrantUsbPrinterAccess(
+      const std::string& extension_id,
+      int device_id,
+      const PrinterProviderAPI::UsbAccessGrantedCallback& callback) override {
+    EXPECT_EQ("fake extension id", extension_id);
+    EXPECT_EQ(0, device_id);
+    pending_usb_access_granted_callbacks_.push(callback);
   }
 
   size_t pending_get_printers_count() const {
@@ -331,8 +349,8 @@ class FakePrinterProviderAPI : public PrinterProviderAPI {
   void TriggerNextGetPrintersCallback(const base::ListValue& printers,
                                       bool done) {
     ASSERT_GT(pending_get_printers_count(), 0u);
-    pending_printers_callbacks_[0].Run(printers, done);
-    pending_printers_callbacks_.erase(pending_printers_callbacks_.begin());
+    pending_printers_callbacks_.front().Run(printers, done);
+    pending_printers_callbacks_.pop();
   }
 
   size_t pending_get_capability_count() const {
@@ -342,8 +360,8 @@ class FakePrinterProviderAPI : public PrinterProviderAPI {
   void TriggerNextGetCapabilityCallback(
       const base::DictionaryValue& description) {
     ASSERT_GT(pending_get_capability_count(), 0u);
-    pending_capability_callbacks_[0].Run(description);
-    pending_capability_callbacks_.erase(pending_capability_callbacks_.begin());
+    pending_capability_callbacks_.front().Run(description);
+    pending_capability_callbacks_.pop();
   }
 
   size_t pending_print_count() const { return pending_print_requests_.size(); }
@@ -352,22 +370,35 @@ class FakePrinterProviderAPI : public PrinterProviderAPI {
     EXPECT_GT(pending_print_count(), 0u);
     if (pending_print_count() == 0)
       return NULL;
-    return &pending_print_requests_[0].job;
+    return &pending_print_requests_.front().job;
   }
 
   void TriggerNextPrintCallback(const std::string& result) {
     ASSERT_GT(pending_print_count(), 0u);
-    pending_print_requests_[0].callback.Run(result == kPrintRequestSuccess,
-                                            result);
-    pending_print_requests_.erase(pending_print_requests_.begin());
+    pending_print_requests_.front().callback.Run(result == kPrintRequestSuccess,
+                                                 result);
+    pending_print_requests_.pop();
+  }
+
+  size_t pending_usb_access_granted_count() const {
+    return pending_usb_access_granted_callbacks_.size();
+  }
+
+  void TriggerNextUsbAccessGrantedCallback(
+      const base::DictionaryValue& printer_info) {
+    ASSERT_GT(pending_usb_access_granted_count(), 0u);
+    pending_usb_access_granted_callbacks_.front().Run(printer_info);
+    pending_usb_access_granted_callbacks_.pop();
   }
 
  private:
-  std::vector<PrinterProviderAPI::GetPrintersCallback>
+  std::queue<PrinterProviderAPI::GetPrintersCallback>
       pending_printers_callbacks_;
-  std::vector<PrinterProviderAPI::GetCapabilityCallback>
+  std::queue<PrinterProviderAPI::GetCapabilityCallback>
       pending_capability_callbacks_;
-  std::vector<PrintRequestInfo> pending_print_requests_;
+  std::queue<PrintRequestInfo> pending_print_requests_;
+  std::queue<PrinterProviderAPI::UsbAccessGrantedCallback>
+      pending_usb_access_granted_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FakePrinterProviderAPI);
 };
@@ -922,3 +953,57 @@ TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_FailedConversion) {
   EXPECT_FALSE(success);
   EXPECT_EQ("INVALID_DATA", status);
 }
+
+TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess) {
+  size_t call_count = 0;
+  scoped_ptr<base::DictionaryValue> printer_info;
+
+  extension_printer_handler_->StartGrantUsbPrinterAccess(
+      "fake extension id", 0,
+      base::Bind(&RecordPrinterInfo, &call_count, &printer_info));
+
+  EXPECT_FALSE(printer_info.get());
+  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
+  ASSERT_TRUE(fake_api);
+  ASSERT_EQ(1u, fake_api->pending_usb_access_granted_count());
+
+  scoped_ptr<base::DictionaryValue> original_printer_info(
+      DictionaryBuilder()
+          .Set("id", "printer1")
+          .Set("name", "Printer 1")
+          .Build());
+
+  fake_api->TriggerNextUsbAccessGrantedCallback(*original_printer_info);
+
+  EXPECT_EQ(1u, call_count);
+  ASSERT_TRUE(printer_info.get());
+  EXPECT_TRUE(printer_info->Equals(original_printer_info.get()))
+      << *printer_info << ", expected: " << *original_printer_info;
+}
+
+TEST_F(ExtensionPrinterHandlerTest, GrantUsbPrinterAccess_Reset) {
+  size_t call_count = 0;
+  scoped_ptr<base::DictionaryValue> printer_info;
+
+  extension_printer_handler_->StartGrantUsbPrinterAccess(
+      "fake extension id", 0,
+      base::Bind(&RecordPrinterInfo, &call_count, &printer_info));
+
+  EXPECT_FALSE(printer_info.get());
+  FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
+  ASSERT_TRUE(fake_api);
+  ASSERT_EQ(1u, fake_api->pending_usb_access_granted_count());
+
+  extension_printer_handler_->Reset();
+
+  scoped_ptr<base::DictionaryValue> original_printer_info(
+      DictionaryBuilder()
+          .Set("id", "printer1")
+          .Set("name", "Printer 1")
+          .Build());
+
+  fake_api->TriggerNextUsbAccessGrantedCallback(*original_printer_info);
+
+  EXPECT_EQ(0u, call_count);
+  EXPECT_FALSE(printer_info.get());
+}