Add onGetUsbPrinterInfoRequested event to printerProvider API.

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

 // Copyright 2015 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 <queue>
 #include <string>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/local_discovery/pwg_raster_converter.h"
 #include "chrome/browser/ui/webui/print_preview/extension_printer_handler.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
+#include "extensions/common/value_builder.h"
 #include "printing/pdf_render_settings.h"
 #include "printing/pwg_raster_settings.h"
 #include "printing/units.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/geometry/size.h"
 
+using extensions::DictionaryBuilder;
 using extensions::PrinterProviderAPI;
 using extensions::PrinterProviderPrintJob;
 using local_discovery::PWGRasterConverter;
 
 namespace {
 
 // Printer id used for requests in tests.
 const char kPrinterId[] = "printer_id";
 
 // Printer list used a result for getPrinters.
@@ skipping 112 matching lines @@
 void RecordPrintResult(size_t* call_count,
                        bool* success_out,
                        std::string* status_out,
                        bool success,
                        const std::string& status) {
   ++(*call_count);
   *success_out = success;
   *status_out = status;
 }
 
+// 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,
                                                std::string* error) {
   scoped_ptr<base::Value> deserialized(
       JSONStringValueDeserializer(json).Deserialize(NULL, error));
   if (!deserialized)
     return scoped_ptr<base::ListValue>();
   base::ListValue* list = nullptr;
   if (!deserialized->GetAsList(&list)) {
@@ skipping 98 matching lines @@
 // Fake PrinterProviderAPI used in tests.
 // It caches requests issued to API and exposes methods to trigger their
 // callbacks.
 class FakePrinterProviderAPI : public PrinterProviderAPI {
  public:
   FakePrinterProviderAPI() = default;
   ~FakePrinterProviderAPI() override = default;
 
   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(
       const PrinterProviderPrintJob& job,
       const PrinterProviderAPI::PrintCallback& callback) override {
     PrintRequestInfo request_info;
     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 {
     return pending_printers_callbacks_.size();
   }
 
   const PrinterProviderPrintJob* GetPrintJob(
       const extensions::Extension* extension,
       int request_id) const override {
     ADD_FAILURE() << "Not reached";
     return nullptr;
   }
 
   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 {
     return pending_capability_callbacks_.size();
   }
 
   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(); }
 
   const PrinterProviderPrintJob* GetNextPendingPrintJob() const {
     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);
 };
 
 KeyedService* BuildTestingPrinterProviderAPI(content::BrowserContext* context) {
   return new FakePrinterProviderAPI();
 }
 
 }  // namespace
 
@@ skipping 426 matching lines @@
   extension_printer_handler_->StartPrint(
       kPrinterId, kPWGRasterOnlyPrinterSimpleDescription, title,
       kEmptyPrintTicket, gfx::Size(100, 100), print_data,
       base::Bind(&RecordPrintResult, &call_count, &success, &status));
 
   EXPECT_EQ(1u, call_count);
 
   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());
+}