Include USB printers in printer list as "provisional" devices.

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 1f701a6067c5e30f63824dfd9903e15a018636e1..d598cc975905ea5c2552c2d3cc12eeb95123e0a3 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
@@ -14,22 +14,34 @@
 #include "base/run_loop.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/test/values_test_util.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/test_extension_environment.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 "device/core/device_client.h"
+#include "device/usb/mock_usb_device.h"
+#include "device/usb/mock_usb_service.h"
+#include "extensions/browser/api/device_permissions_manager.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/extension.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 device::MockUsbDevice;
+using device::MockUsbService;
+using extensions::DictionaryBuilder;
+using extensions::Extension;
 using extensions::PrinterProviderAPI;
 using extensions::PrinterProviderPrintJob;
+using extensions::TestExtensionEnvironment;
 using local_discovery::PWGRasterConverter;
 
 namespace {
@@ -160,6 +172,14 @@ void RecordPrintResult(size_t* call_count,
   *status_out = status;
 }
 
+// Used as a callback to StartGetUsbPrinters in tests.
+void RecordListValue(scoped_ptr<base::ListValue>* list_value_out,
+                     const base::Closure& callback,
+                     const base::ListValue& list_value) {
+  list_value_out->reset(list_value.DeepCopy());
+  callback.Run();
+}
+
 // Converts JSON string to base::ListValue object.
 // On failure, returns NULL and fills |*error| string.
 scoped_ptr<base::ListValue> GetJSONAsListValue(const std::string& json,
@@ -356,6 +376,22 @@ KeyedService* BuildTestingPrinterProviderAPI(content::BrowserContext* context) {
   return new FakePrinterProviderAPI();
 }
 
+class FakeDeviceClient : public device::DeviceClient {
+ public:
+  FakeDeviceClient() {}
+
+  // device::DeviceClient implementation:
+  device::UsbService* GetUsbService() override {
+    DCHECK(usb_service_);
+    return usb_service_;
+  }
+
+  void set_usb_service(device::UsbService* service) { usb_service_ = service; }
+
+ private:
+  device::UsbService* usb_service_ = nullptr;
+};
+
 }  // namespace
 
 class ExtensionPrinterHandlerTest : public testing::Test {
@@ -364,35 +400,33 @@ class ExtensionPrinterHandlerTest : public testing::Test {
   ~ExtensionPrinterHandlerTest() override = default;
 
   void SetUp() override {
-    TestingProfile::Builder profile_builder;
-    profile_builder.AddTestingFactory(
-        extensions::PrinterProviderAPIFactory::GetInstance(),
-        &BuildTestingPrinterProviderAPI);
-    profile_ = profile_builder.Build();
-
+    env_.reset(new TestExtensionEnvironment());
+    extensions::PrinterProviderAPIFactory::GetInstance()->SetTestingFactory(
+        env_->profile(), &BuildTestingPrinterProviderAPI);
     extension_printer_handler_.reset(new ExtensionPrinterHandler(
-        profile_.get(), base::MessageLoop::current()->task_runner()));
+        env_->profile(), base::MessageLoop::current()->task_runner()));
 
     pwg_raster_converter_ = new FakePWGRasterConverter();
     extension_printer_handler_->SetPwgRasterConverterForTesting(
         scoped_ptr<PWGRasterConverter>(pwg_raster_converter_));
+    device_client_.set_usb_service(&usb_service_);
   }
 
  protected:
   FakePrinterProviderAPI* GetPrinterProviderAPI() {
     return static_cast<FakePrinterProviderAPI*>(
         extensions::PrinterProviderAPIFactory::GetInstance()
-            ->GetForBrowserContext(profile_.get()));
+            ->GetForBrowserContext(env_->profile()));
   }
 
+  MockUsbService usb_service_;
+  scoped_ptr<TestExtensionEnvironment> env_;
   scoped_ptr<ExtensionPrinterHandler> extension_printer_handler_;
 
   FakePWGRasterConverter* pwg_raster_converter_;
 
  private:
-  content::TestBrowserThreadBundle thread_bundle_;
-
-  scoped_ptr<TestingProfile> profile_;
+  FakeDeviceClient device_client_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionPrinterHandlerTest);
 };
@@ -449,6 +483,100 @@ TEST_F(ExtensionPrinterHandlerTest, GetPrinters_Reset) {
   EXPECT_EQ(0u, call_count);
 }
 
+TEST_F(ExtensionPrinterHandlerTest, GetUsbPrinters) {
+  scoped_refptr<MockUsbDevice> device0 =
+      new MockUsbDevice(0, 0, "Google", "USB Printer", "");
+  usb_service_.AddDevice(device0);
+  scoped_refptr<MockUsbDevice> device1 =
+      new MockUsbDevice(0, 1, "Google", "USB Printer", "");
+  usb_service_.AddDevice(device1);
+
+  const Extension* extension_1 = env_->MakeExtension(*base::test::ParseJson(
+                          "{"
+                          "  \"name\": \"Provider 1\","
+                          "  \"app\": {"
+                          "    \"background\": {"
+                          "      \"scripts\": [\"background.js\"]"
+                          "    }"
+                          "  },"
+                          "  \"permissions\": ["
+                          "    \"printerProvider\","
+                          "    \"usb\","
+                          "    {"
+                          "     \"usbDevices\": ["
+                          "       { \"vendorId\": 0, \"productId\": 1 }"
+                          "     ]"
+                          "    },"
+                          "  ],"
+                          "  \"usb_printers\": {"
+                          "    \"filters\": ["
+                          "      { \"vendorId\": 0, \"productId\": 0 },"
+                          "      { \"vendorId\": 0, \"productId\": 1 }"
+                          "    ]"
+                          "  }"
+                          "}"), "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
+  const Extension* extension_2 = env_->MakeExtension(*base::test::ParseJson(
+                          "{"
+                          "  \"name\": \"Provider 2\","
+                          "  \"app\": {"
+                          "    \"background\": {"
+                          "      \"scripts\": [\"background.js\"]"
+                          "    }"
+                          "  },"
+                          "  \"permissions\": [ \"printerProvider\", \"usb\" ],"
+                          "  \"usb_printers\": {"
+                          "    \"filters\": ["
+                          "      { \"vendorId\": 0, \"productId\": 0 },"
+                          "      { \"vendorId\": 0, \"productId\": 1 }"
+                          "    ]"
+                          "  }"
+                          "}"), "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
+
+  extensions::DevicePermissionsManager* permissions_manager =
+      extensions::DevicePermissionsManager::Get(env_->profile());
+  permissions_manager->AllowUsbDevice(extension_2->id(), device0);
+
+  scoped_ptr<base::ListValue> printers;
+  base::RunLoop run_loop;
+  extension_printer_handler_->StartGetUsbPrinters(
+      base::Bind(&RecordListValue, &printers, run_loop.QuitClosure()));
+  run_loop.Run();
+
+  EXPECT_TRUE(printers.get());
+  EXPECT_EQ(2u, printers->GetSize());
+
+  scoped_ptr<base::DictionaryValue> extension_1_entry(
+      DictionaryBuilder().Set("extensionName", "Provider 1")
+                         .Set("extensionId", extension_1->id()).Build());
+  scoped_ptr<base::DictionaryValue> extension_2_entry(
+      DictionaryBuilder().Set("extensionName", "Provider 2")
+                         .Set("extensionId", extension_2->id()).Build());
+
+  for (size_t i = 0; i < printers->GetSize(); ++i) {
+    const base::DictionaryValue* printer_info;
+    ASSERT_TRUE(printers->GetDictionary(i, &printer_info));
+
+    EXPECT_EQ(3u, printer_info->size());
+    std::string name;
+    EXPECT_TRUE(printer_info->GetString("name", &name));
+    EXPECT_EQ("USB Printer", name);
+    uint32 device_id;
+    EXPECT_TRUE(printer_info->GetInteger(
+        "usbDevice", reinterpret_cast<int*>(&device_id)));
+    const base::ListValue* extensions;
+    EXPECT_TRUE(printer_info->GetList("extensions", &extensions));
+    EXPECT_EQ(1u, extensions->GetSize());
+
+    if (device_id == device0->unique_id()) {
+      EXPECT_TRUE(extensions->Find(*extension_1_entry) != extensions->end());
+    } else if (device_id == device1->unique_id()) {
+      EXPECT_TRUE(extensions->Find(*extension_2_entry) != extensions->end());
+    } else {
+      FAIL();
+    }
+  }
+}
+
 TEST_F(ExtensionPrinterHandlerTest, GetCapability) {
   size_t call_count = 0;
   std::string destination_id;