Add onGetUsbPrinterInfoRequested event to printerProvider API.

extensions/browser/api/printer_provider/printer_provider_apitest.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 "base/bind.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "device/usb/mock_usb_device.h"
+#include "device/usb/mock_usb_service.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/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/value_builder.h"
 #include "extensions/shell/test/shell_apitest.h"
 #include "extensions/test/extension_test_message_listener.h"
 #include "extensions/test/result_catcher.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 37 matching lines @@
 // It saves reported |value| as JSON string to |*result| and runs |callback|.
 void RecordDictAndRunCallback(std::string* result,
                               const base::Closure& callback,
                               const base::DictionaryValue& value) {
   JSONStringValueSerializer serializer(result);
   EXPECT_TRUE(serializer.Serialize(value));
   if (!callback.is_null())
     callback.Run();
 }
 
+// Callback for PrinterProvider::DispatchGrantUsbPrinterAccess calls.
+// It expects |value| to equal |expected_value| and runs |callback|.
+void ExpectValueAndRunCallback(const base::Value* expected_value,
+                               const base::Closure& callback,
+                               const base::DictionaryValue& value) {
+  EXPECT_TRUE(value.Equals(expected_value));
+  if (!callback.is_null())
+    callback.Run();
+}
+
 // Tests for chrome.printerProvider API.
 class PrinterProviderApiTest : public ShellApiTest {
  public:
   enum PrintRequestDataType {
     PRINT_REQUEST_DATA_TYPE_NOT_SET,
     PRINT_REQUEST_DATA_TYPE_FILE,
     PRINT_REQUEST_DATA_TYPE_FILE_DELETED,
     PRINT_REQUEST_DATA_TYPE_BYTES
   };
 
   PrinterProviderApiTest() {}
   ~PrinterProviderApiTest() override {}
 
   void StartGetPrintersRequest(
       const PrinterProviderAPI::GetPrintersCallback& callback) {
     PrinterProviderAPIFactory::GetInstance()
         ->GetForBrowserContext(browser_context())
         ->DispatchGetPrintersRequested(callback);
   }
 
+  void StartGetUsbPrinterInfoRequest(
+      const std::string& extension_id,
+      scoped_refptr<device::UsbDevice> device,
+      const PrinterProviderAPI::GetPrinterInfoCallback& callback) {
+    PrinterProviderAPIFactory::GetInstance()
+        ->GetForBrowserContext(browser_context())
+        ->DispatchGetUsbPrinterInfoRequested(extension_id, device, callback);
+  }
+
   void StartPrintRequestWithNoData(
       const std::string& extension_id,
       const PrinterProviderAPI::PrintCallback& callback) {
     PrinterProviderPrintJob job;
     job.printer_id = extension_id + ":printer_id";
     job.ticket_json = "{}";
     job.content_type = "application/pdf";
 
     PrinterProviderAPIFactory::GetInstance()
         ->GetForBrowserContext(browser_context())
@@ skipping 145 matching lines @@
     StartCapabilityRequest(
         extension_id,
         base::Bind(&RecordDictAndRunCallback, &result, run_loop.QuitClosure()));
 
     ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
     run_loop.Run();
     EXPECT_EQ(expected_result, result);
   }
 
+  // Run a test for the chrome.printerProvider.onGetUsbPrinterInfoRequested
+  // event.
+  // |test_param|: The test that should be run.
+  // |expected_result|: The printer info that the app is expected to report.
+  void RunUsbPrinterInfoRequestTest(const std::string& test_param) {
+    ResultCatcher catcher;
+    scoped_refptr<device::UsbDevice> device =
+        new device::MockUsbDevice(0, 0, "Google", "USB Printer", "");
+    usb_service_.AddDevice(device);
+
+    std::string extension_id;
+    InitializePrinterProviderTestApp("api_test/printer_provider/usb_printers",
+                                     test_param, &extension_id);
+    ASSERT_FALSE(extension_id.empty());
+
+    scoped_ptr<base::Value> expected_printer_info(new base::DictionaryValue());
+    base::RunLoop run_loop;
+    StartGetUsbPrinterInfoRequest(
+        extension_id, device,
+        base::Bind(&ExpectValueAndRunCallback, expected_printer_info.get(),
+                   run_loop.QuitClosure()));
+    run_loop.Run();
+
+    ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
+  }
+
   bool SimulateExtensionUnload(const std::string& extension_id) {
     ExtensionRegistry* extension_registry =
         ExtensionRegistry::Get(browser_context());
 
     const Extension* extension = extension_registry->GetExtensionById(
         extension_id, ExtensionRegistry::ENABLED);
     if (!extension)
       return false;
 
     extension_registry->RemoveEnabled(extension_id);
     extension_registry->TriggerOnUnloaded(
         extension, UnloadedExtensionInfo::REASON_TERMINATE);
     return true;
   }
 
   // Validates that set of printers reported by test apps via
   // chrome.printerProvider.onGetPritersRequested is the same as the set of
   // printers in |expected_printers|. |expected_printers| contains list of
   // printer objects formatted as a JSON string. It is assumed that the values
   // in |expoected_printers| are unique.
   void ValidatePrinterListValue(
       const base::ListValue& printers,
       const ScopedVector<base::Value>& expected_printers) {
     ASSERT_EQ(expected_printers.size(), printers.GetSize());
     for (const base::Value* printer_value : expected_printers) {
       EXPECT_TRUE(printers.Find(*printer_value) != printers.end())
-          << "Unabe to find " << *printer_value << " in " << printers;
+          << "Unable to find " << *printer_value << " in " << printers;
     }
   }
 
+ protected:
+  device::MockUsbService usb_service_;
+
  private:
   // Initializes |data_dir_| if needed and creates a file in it containing
   // provided data.
   bool CreateTempFileWithContents(const char* data,
                                   int size,
                                   base::FilePath* path,
                                   base::File::Info* file_info) {
     if (!data_dir_.IsValid() && !data_dir_.CreateUniqueTempDir())
       return false;
 
@@ skipping 453 matching lines @@
   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
                                      &printers, run_loop.QuitClosure()));
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   run_loop.Run();
 
   EXPECT_TRUE(printers.empty());
 }
 
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetUsbPrinterInfo) {
+  ResultCatcher catcher;
+  scoped_refptr<device::UsbDevice> device =
+      new device::MockUsbDevice(0, 0, "Google", "USB Printer", "");
+  usb_service_.AddDevice(device);
+
+  std::string extension_id;
+  InitializePrinterProviderTestApp("api_test/printer_provider/usb_printers",
+                                   "OK", &extension_id);
+  ASSERT_FALSE(extension_id.empty());
+
+  scoped_ptr<base::Value> expected_printer_info(
+      DictionaryBuilder()
+          .Set("description", "This printer is a USB device.")
+          .Set("extensionId", extension_id)
+          .Set("extensionName", "Test USB printer provider")
+          .Set("id", base::StringPrintf("%s:usbDevice-%u", extension_id.c_str(),
+                                        device->unique_id()))
+          .Set("name", "Test Printer")
+          .Build());
+  base::RunLoop run_loop;
+  StartGetUsbPrinterInfoRequest(
+      extension_id, device,
+      base::Bind(&ExpectValueAndRunCallback, expected_printer_info.get(),
+                 run_loop.QuitClosure()));
+  run_loop.Run();
+
+  ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
+}
+
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetUsbPrinterInfoEmptyResponse) {
+  RunUsbPrinterInfoRequestTest("EMPTY_RESPONSE");
+}
+
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetUsbPrinterInfoNoListener) {
+  RunUsbPrinterInfoRequestTest("NO_LISTENER");
+}
+
 }  // namespace
 
 }  // namespace extensions