List printers managed by extensions in print preview

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

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
@@ skipping 71 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #endif
 
 #if defined(ENABLE_SERVICE_DISCOVERY)
 #include "chrome/browser/local_discovery/privet_constants.h"
 #endif
 
+#if defined(ENABLE_EXTENSIONS)
+#include "extensions/browser/api/printer_provider/printer_provider_api.h"
+#endif
+
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::WebContents;
 
 namespace {
 
 enum UserActionBuckets {
   PRINT_TO_PRINTER,
   PRINT_TO_PDF,
   CANCEL,
@@ skipping 538 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getPrivetPrinters",
       base::Bind(&PrintPreviewHandler::HandleGetPrivetPrinters,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("stopGetPrivetPrinters",
       base::Bind(&PrintPreviewHandler::HandleStopGetPrivetPrinters,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getPrivetPrinterCapabilities",
       base::Bind(&PrintPreviewHandler::HandleGetPrivetPrinterCapabilities,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getExtensionPrinters",
+      base::Bind(&PrintPreviewHandler::HandleGetExtensionPrinters,
+                 base::Unretained(this)));
+  web_ui()->RegisterMessageCallback(
+      "getExtensionPrinterCapabilities",
+      base::Bind(&PrintPreviewHandler::HandleGetExtensionPrinterCapabilities,
+                 base::Unretained(this)));
   RegisterForMergeSession();
 }
 
 bool PrintPreviewHandler::PrivetPrintingEnabled() {
 #if defined(ENABLE_SERVICE_DISCOVERY)
   return true;
 #else
   return false;
 #endif
 }
@@ skipping 39 matching lines @@
   bool success = args->GetString(0, &name);
   DCHECK(success);
 
   CreatePrivetHTTP(
       name,
       base::Bind(&PrintPreviewHandler::PrivetCapabilitiesUpdateClient,
                  base::Unretained(this)));
 #endif
 }
 
+void PrintPreviewHandler::HandleGetExtensionPrinters(
+    const base::ListValue* args) {
+#if defined(ENABLE_EXTENSIONS)
+  // TODO(tbarzic): Handle case where a new search is initiated before the
+  // previous one finishes. Currently, in this case Web UI layer may get
+  // multiple events with printer list from some extensions, and it may get
+  // fooled by |done| flag from the first search into marking the search
+  // complete.

[Aleksey Shlyapnikov, 2015/02/03 20:18:24]

I'm fine with implementing it later. Just curious, are you planning to add a
token to the request to filter out obsolete results or counter on the js side to
wait for all outstanding requests to finish?

[tbarzic, 2015/02/04 02:21:23]

Closer to former. I'll probably just end up invalidating weak ptr to which the
callback is bound (effectively filtering out obsolete results).

+  extensions::PrinterProviderAPI::GetFactoryInstance()
+      ->Get(preview_web_contents()->GetBrowserContext())
+      ->DispatchGetPrintersRequested(
+          base::Bind(&PrintPreviewHandler::OnGotPrintersForExtension,
+                     weak_factory_.GetWeakPtr()));
+#else
+  OnGotPrintersForExtension(base::ListValue(), true /* done */);
+#endif
+}
+
+void PrintPreviewHandler::HandleGetExtensionPrinterCapabilities(
+    const base::ListValue* args) {
+  std::string extension_id;
+  std::string printer_id;
+  bool ok = args->GetString(0, &extension_id);
+  DCHECK(ok);
+  ok = args->GetString(1, &printer_id);
+  DCHECK(ok);
+
+#if defined(ENABLE_EXTENSIONS)
+  extensions::PrinterProviderAPI::GetFactoryInstance()
+      ->Get(preview_web_contents()->GetBrowserContext())
+      ->DispatchGetCapabilityRequested(
+          extension_id, printer_id,
+          base::Bind(&PrintPreviewHandler::OnGotExtensionPrinterCapabilities,
+                     weak_factory_.GetWeakPtr(), extension_id, printer_id));
+#else
+  OnGotExtensionPrinterCapabilities(extension_id, printer_id,
+                                    base::DictionaryValue());

[Aleksey Shlyapnikov, 2015/02/03 20:18:24]

Empty capabilities are not valid. How do you plan to handle failure case? What
if that extension does not handle that printer anymore or just want to report a
problem?

[tbarzic, 2015/02/04 02:21:23]

Added error handling.

+#endif
+}
+
 void PrintPreviewHandler::HandleGetPreview(const base::ListValue* args) {
   DCHECK_EQ(3U, args->GetSize());
   scoped_ptr<base::DictionaryValue> settings(GetSettingsDictionary(args));
   if (!settings.get())
     return;
   int request_id = -1;
   if (!settings->GetInteger(printing::kPreviewRequestID, &request_id))
     return;
 
   PrintPreviewUI* print_preview_ui = static_cast<PrintPreviewUI*>(
@@ skipping 862 matching lines @@
   printer_value->SetBoolean("hasLocalPrinting", has_local_printing);
   printer_value->SetBoolean(
       "isUnregistered",
       description.id.empty() &&
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos));
   printer_value->SetString("cloudID", description.id);
 }
 
 #endif  // defined(ENABLE_SERVICE_DISCOVERY)
 
+void PrintPreviewHandler::OnGotPrintersForExtension(
+    const base::ListValue& printers,
+    bool done) {
+  web_ui()->CallJavascriptFunction("onExtensionPrintersAdded", printers,
+                                   base::FundamentalValue(done));
+}
+
+void PrintPreviewHandler::OnGotExtensionPrinterCapabilities(
+    const std::string& extension_id,
+    const std::string& printer_id,
+    const base::DictionaryValue& capabilities) {
+  web_ui()->CallJavascriptFunction("onExtensionCapabilitiesSet",
+                                   base::StringValue(extension_id),
+                                   base::StringValue(printer_id),
+                                   capabilities);
+}
+
 void PrintPreviewHandler::RegisterForMergeSession() {
   DCHECK(!reconcilor_);
   Profile* profile = Profile::FromWebUI(web_ui());
   if (switches::IsEnableAccountConsistency() && !profile->IsOffTheRecord()) {
     reconcilor_ = AccountReconcilorFactory::GetForProfile(profile);
     if (reconcilor_)
       reconcilor_->AddMergeSessionObserver(this);
   }
 }
 
 void PrintPreviewHandler::UnregisterForMergeSession() {
   if (reconcilor_)
     reconcilor_->RemoveMergeSessionObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }