Move cloud print specific files out of local_discovery

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 <stddef.h>
 #include <map>
 #include <string>
@@ skipping 76 matching lines @@
 #include "printing/printing_context.h"
 #include "printing/units.h"
 #include "third_party/icu/source/i18n/unicode/ulocdata.h"
 
 #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"
+#include "chrome/browser/printing/cloud_print/privet_constants.h"
 #endif
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::WebContents;
 
 namespace {
 
 enum UserActionBuckets {
   PRINT_TO_PRINTER,
@@ skipping 1434 matching lines @@
 
 void PrintPreviewHandler::StartPrivetLister(const scoped_refptr<
     local_discovery::ServiceDiscoverySharedClient>& client) {
   if (!PrivetPrintingEnabled())
     return web_ui()->CallJavascriptFunction("onPrivetPrinterSearchDone");
 
   Profile* profile = Profile::FromWebUI(web_ui());
   DCHECK(!service_discovery_client_.get() ||
          service_discovery_client_.get() == client.get());
   service_discovery_client_ = client;
-  printer_lister_.reset(new local_discovery::PrivetLocalPrinterLister(
+  printer_lister_.reset(new cloud_print::PrivetLocalPrinterLister(
       service_discovery_client_.get(), profile->GetRequestContext(), this));
   printer_lister_->Start();
 }
 
 void PrintPreviewHandler::LocalPrinterChanged(
     bool added,
     const std::string& name,
     bool has_local_printing,
-    const local_discovery::DeviceDescription& description) {
+    const cloud_print::DeviceDescription& description) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   if (has_local_printing ||
       command_line->HasSwitch(switches::kEnablePrintPreviewRegisterPromos)) {
     base::DictionaryValue info;
     FillPrinterDescription(name, description, has_local_printing, &info);
     web_ui()->CallJavascriptFunction("onPrivetPrinterChanged", info);
   }
 }
 
 void PrintPreviewHandler::LocalPrinterRemoved(const std::string& name) {
 }
 
 void PrintPreviewHandler::LocalPrinterCacheFlushed() {
 }
 
 void PrintPreviewHandler::PrivetCapabilitiesUpdateClient(
-    scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
+    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!PrivetUpdateClient(std::move(http_client)))
     return;
 
   privet_capabilities_operation_ =
       privet_http_client_->CreateCapabilitiesOperation(
           base::Bind(&PrintPreviewHandler::OnPrivetCapabilities,
                      base::Unretained(this)));
   privet_capabilities_operation_->Start();
 }
 
 bool PrintPreviewHandler::PrivetUpdateClient(
-    scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
+    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!http_client) {
     SendPrivetCapabilitiesError(privet_http_resolution_->GetName());
     privet_http_resolution_.reset();
     return false;
   }
 
   privet_local_print_operation_.reset();
   privet_capabilities_operation_.reset();
-  privet_http_client_ = local_discovery::PrivetV1HTTPClient::CreateDefault(
+  privet_http_client_ = cloud_print::PrivetV1HTTPClient::CreateDefault(
       std::move(http_client));
 
   privet_http_resolution_.reset();
 
   return true;
 }
 
 void PrintPreviewHandler::PrivetLocalPrintUpdateClient(
     std::string print_ticket,
     std::string capabilities,
     gfx::Size page_size,
-    scoped_ptr<local_discovery::PrivetHTTPClient> http_client) {
+    scoped_ptr<cloud_print::PrivetHTTPClient> http_client) {
   if (!PrivetUpdateClient(std::move(http_client)))
     return;
 
   StartPrivetLocalPrint(print_ticket, capabilities, page_size);
 }
 
 void PrintPreviewHandler::StartPrivetLocalPrint(const std::string& print_ticket,
                                                 const std::string& capabilities,
                                                 const gfx::Size& page_size) {
   privet_local_print_operation_ =
@@ skipping 25 matching lines @@
   }
 
   privet_local_print_operation_->Start();
 }
 
 
 void PrintPreviewHandler::OnPrivetCapabilities(
     const base::DictionaryValue* capabilities) {
   std::string name = privet_capabilities_operation_->GetHTTPClient()->GetName();
 
-  if (!capabilities || capabilities->HasKey(local_discovery::kPrivetKeyError) ||
+  if (!capabilities || capabilities->HasKey(cloud_print::kPrivetKeyError) ||
       !printer_lister_) {
     SendPrivetCapabilitiesError(name);
     return;
   }
 
   base::DictionaryValue printer_info;
-  const local_discovery::DeviceDescription* description =
+  const cloud_print::DeviceDescription* description =
       printer_lister_->GetDeviceDescription(name);
 
   if (!description) {
     SendPrivetCapabilitiesError(name);
     return;
   }
 
   FillPrinterDescription(name, *description, true, &printer_info);
 
   web_ui()->CallJavascriptFunction(
@@ skipping 20 matching lines @@
       device_name,
       base::Bind(&PrintPreviewHandler::PrivetLocalPrintUpdateClient,
                  base::Unretained(this),
                  ticket,
                  capabilities,
                  page_size));
 }
 
 bool PrintPreviewHandler::CreatePrivetHTTP(
     const std::string& name,
-    const local_discovery::PrivetHTTPAsynchronousFactory::ResultCallback&
+    const cloud_print::PrivetHTTPAsynchronousFactory::ResultCallback&
         callback) {
-  const local_discovery::DeviceDescription* device_description =
+  const cloud_print::DeviceDescription* device_description =
       printer_lister_ ? printer_lister_->GetDeviceDescription(name) : NULL;
 
   if (!device_description) {
     SendPrivetCapabilitiesError(name);
     return false;
   }
 
   privet_http_factory_ =
-      local_discovery::PrivetHTTPAsynchronousFactory::CreateInstance(
+      cloud_print::PrivetHTTPAsynchronousFactory::CreateInstance(
           Profile::FromWebUI(web_ui())->GetRequestContext());
   privet_http_resolution_ = privet_http_factory_->CreatePrivetHTTP(name);
   privet_http_resolution_->Start(device_description->address, callback);
 
   return true;
 }
 
 void PrintPreviewHandler::OnPrivetPrintingDone(
-    const local_discovery::PrivetLocalPrintOperation* print_operation) {
+    const cloud_print::PrivetLocalPrintOperation* print_operation) {
   ClosePreviewDialog();
 }
 
 void PrintPreviewHandler::OnPrivetPrintingError(
-    const local_discovery::PrivetLocalPrintOperation* print_operation,
+    const cloud_print::PrivetLocalPrintOperation* print_operation,
     int http_code) {
   base::FundamentalValue http_code_value(http_code);
   web_ui()->CallJavascriptFunction("onPrivetPrintFailed", http_code_value);
 }
 
 void PrintPreviewHandler::FillPrinterDescription(
     const std::string& name,
-    const local_discovery::DeviceDescription& description,
+    const cloud_print::DeviceDescription& description,
     bool has_local_printing,
     base::DictionaryValue* printer_value) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   printer_value->SetString("serviceName", name);
   printer_value->SetString("name", description.name);
   printer_value->SetBoolean("hasLocalPrinting", has_local_printing);
   printer_value->SetBoolean(
       "isUnregistered",
       description.id.empty() &&
@@ skipping 71 matching lines @@
 
 void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
   if (gaia_cookie_manager_service_)
     gaia_cookie_manager_service_->RemoveObserver(this);
 }
 
 void PrintPreviewHandler::SetPdfSavedClosureForTesting(
     const base::Closure& closure) {
   pdf_file_saved_closure_ = closure;
 }