Introduce concept of provisional destinations to print preview

extensions/browser/api/printer_provider/printer_provider_api.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 "extensions/browser/api/printer_provider/printer_provider_api.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/scoped_observer.h"
 #include "base/strings/string16.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "device/core/device_client.h"
 #include "device/usb/usb_device.h"
 #include "device/usb/usb_service.h"
 #include "extensions/browser/api/device_permissions_manager.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
 #include "extensions/browser/api/printer_provider_internal/printer_provider_internal_api.h"
 #include "extensions/browser/api/printer_provider_internal/printer_provider_internal_api_observer.h"
 #include "extensions/browser/event_router.h"
@@ skipping 23 matching lines @@
 // generates a ID for the printer unique across extensions (assuming that the
 // printer id is unique in the extension's space).
 std::string GeneratePrinterId(const std::string& extension_id,
                               const std::string& internal_printer_id) {
   std::string result = extension_id;
   result.append(1, kPrinterIdSeparator);
   result.append(internal_printer_id);
   return result;
 }
 
+std::string GenerateUsbExtensionPrinterId(const std::string& extension_id,
+                                          int usb_device_id) {
+  std::string result("usb-");
+  result.append(
+      GeneratePrinterId(extension_id,
+                        base::IntToString(usb_device_id)));
+  return result;
+}
+
 // Parses an ID created using |GeneratePrinterId| to it's components:
 // the extension ID and the printer ID internal to the extension.
 // Returns whenter the ID was succesfully parsed.
 bool ParsePrinterId(const std::string& printer_id,
                     std::string* extension_id,
                     std::string* internal_printer_id) {
   size_t separator = printer_id.find_first_of(kPrinterIdSeparator);
   if (separator == std::string::npos)
     return false;
   *extension_id = printer_id.substr(0, separator);
@@ skipping 143 matching lines @@
   PendingUsbPrinterInfoRequests();
   ~PendingUsbPrinterInfoRequests();
 
   // Adds a new request to the set. Only information needed is the callback
   // associated with the request. Returns the id assigned to the request.
   int Add(const PrinterProviderAPI::UsbAccessGrantedCallback& callback);
 
   // Completes the request with the provided request id. It runs the request
   // callback and removes the request from the set.
   void Complete(int request_id,
-                const core_api::printer_provider::PrinterInfo* printer_info);
+                const base::DictionaryValue* printer_info);
 
   // Runs all pending callbacks with empty capability value and clears the
   // set of pending requests.
   void FailAll();
 
  private:
   int last_request_id_ = 0;
   std::map<int, PrinterProviderAPI::UsbAccessGrantedCallback> pending_requests_;
 };
 
@@ skipping 262 matching lines @@
 }
 
 int PendingUsbPrinterInfoRequests::Add(
     const PrinterProviderAPI::UsbAccessGrantedCallback& callback) {
   pending_requests_[++last_request_id_] = callback;
   return last_request_id_;
 }
 
 void PendingUsbPrinterInfoRequests::Complete(
     int request_id,
-    const core_api::printer_provider::PrinterInfo* printer_info) {
+    const base::DictionaryValue* printer_info) {
   auto it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     return;
   }
 
   PrinterProviderAPI::UsbAccessGrantedCallback callback = it->second;
   pending_requests_.erase(it);
 
   if (printer_info) {
-    callback.Run(*printer_info->ToValue().get());
+    callback.Run(*printer_info);
   } else {
     callback.Run(base::DictionaryValue());
   }
 }
 
 void PendingUsbPrinterInfoRequests::FailAll() {
   for (auto& request : pending_requests_) {
     request.second.Run(base::DictionaryValue());
   }
   pending_requests_.clear();
@@ skipping 251 matching lines @@
           : core_api::printer_provider_internal::ToString(error);
   pending_print_requests_[extension->id()].Complete(
       request_id, error == core_api::printer_provider_internal::PRINT_ERROR_OK,
       error_str);
 }
 
 void PrinterProviderAPIImpl::OnUsbAccessGrantedResult(
     const Extension* extension,
     int request_id,
     const core_api::printer_provider::PrinterInfo* printer_info) {
+  if (!printer_info) {
+    pending_usb_printer_info_requests_[extension->id()].Complete(
+        request_id, NULL);
+    return;
+  }
+
+  scoped_ptr<base::DictionaryValue> printer(printer_info->ToValue());
+  std::string internal_printer_id;
+  CHECK(printer->GetString("id", &internal_printer_id));
+  printer->SetString("id",
+                     GeneratePrinterId(extension->id(), internal_printer_id));
+  printer->SetString("extensionId", extension->id());
+  printer->SetString("extensionName", extension->name());
+
+  base::string16 printer_name;
+  if (printer->GetString("name", &printer_name) &&
+      base::i18n::AdjustStringForLocaleDirection(&printer_name)) {
+    printer->SetString("name", printer_name);
+  }
+
+  base::string16 printer_description;
+  if (printer->GetString("description", &printer_description) &&
+      base::i18n::AdjustStringForLocaleDirection(&printer_description)) {
+    printer->SetString("description", printer_description);
+  }
+
   pending_usb_printer_info_requests_[extension->id()].Complete(request_id,
-                                                               printer_info);
+                                                               printer.get());
 }
 
 void PrinterProviderAPIImpl::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   pending_get_printers_requests_.FailAllForExtension(extension->id());
 
   auto print_it = pending_print_requests_.find(extension->id());
   if (print_it != pending_print_requests_.end()) {
@@ skipping 52 matching lines @@
 
     for (const auto& device : devices) {
       if (manifest_data->SupportsDevice(device)) {
         result_map[device].push_back(extension);
       }
     }
   }
 
   ListBuilder printer_list;
   for (const auto& map_entry : result_map) {
+    const scoped_refptr<UsbDevice>& device = map_entry.first;
+
     ListBuilder extension_list;
     for (const scoped_refptr<const Extension>& extension : map_entry.second) {
-      extension_list.Append(DictionaryBuilder()
-                                .Set("extensionId", extension->id())
-                                .Set("extensionName", extension->name()));
+      extension_list.Append(
+          DictionaryBuilder()
+              .Set("extensionId", extension->id())
+              .Set("extensionName", extension->name())
+              .Set("printerId",
+                   GenerateUsbExtensionPrinterId(
+                       extension->id(),
+                       static_cast<int>(device->unique_id()))));
     }
 
-    const scoped_refptr<UsbDevice>& device = map_entry.first;
     printer_list.Append(
         DictionaryBuilder()
             .Set("name", DevicePermissionsManager::GetPermissionMessage(
                              device->vendor_id(), device->product_id(),
                              device->manufacturer_string(),
                              device->product_string(), base::string16(), false))
             .Set("usbDevice", static_cast<int>(device->unique_id()))
-            .Set("extensions", extension_list.Pass()));
+            .Set("extensions", extension_list.Pass())
+            .Set("needsUsbPermission", true));
   }
 
   pending_get_printers_requests_.CompleteUsbPrinters(
       request_id, *printer_list.Build().get());
 }
 
 }  // namespace
 
 // static
 PrinterProviderAPI* PrinterProviderAPI::Create(
     content::BrowserContext* context) {
   return new PrinterProviderAPIImpl(context);
 }
 
 // static
 std::string PrinterProviderAPI::GetDefaultPrintError() {
   return core_api::printer_provider_internal::ToString(
       core_api::printer_provider_internal::PRINT_ERROR_FAILED);
 }
 
 }  // namespace extensions