Make chromeos CUPS printing code namespaces consistent.

chrome/browser/chromeos/printing/printer_configurer.cc

 // Copyright 2017 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/chromeos/printing/printer_configurer.h"
 
+#include <map>
 #include <memory>
+#include <set>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/printing/ppd_provider_factory.h"
@@ skipping 18 matching lines @@
 
 namespace chromeos {
 
 namespace {
 
 // Configures printers by downloading PPDs then adding them to CUPS through
 // debugd.  This class must be used on the UI thread.
 class PrinterConfigurerImpl : public PrinterConfigurer {
  public:
   explicit PrinterConfigurerImpl(Profile* profile)
-      : ppd_provider_(printing::CreateProvider(profile)), weak_factory_(this) {}
+      : ppd_provider_(CreatePpdProvider(profile)), weak_factory_(this) {}
 
   PrinterConfigurerImpl(const PrinterConfigurerImpl&) = delete;
   PrinterConfigurerImpl& operator=(const PrinterConfigurerImpl&) = delete;
 
   ~PrinterConfigurerImpl() override {}
 
   void SetUpPrinter(const Printer& printer,
                     const PrinterSetupCallback& callback) override {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     DCHECK(!printer.id().empty());
     DCHECK(!printer.uri().empty());
 
     if (!printer.IsIppEverywhere()) {
       ppd_provider_->ResolvePpd(
           printer.ppd_reference(),
           base::Bind(&PrinterConfigurerImpl::ResolvePpdDone,
                      weak_factory_.GetWeakPtr(), printer, callback));
       return;
     }
 
-    auto* client = chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
+    auto* client = DBusThreadManager::Get()->GetDebugDaemonClient();
 
     client->CupsAddAutoConfiguredPrinter(
         printer.id(), printer.uri(),
         base::Bind(&PrinterConfigurerImpl::OnAddedPrinter,
                    weak_factory_.GetWeakPtr(), printer, callback),
         base::Bind(&PrinterConfigurerImpl::OnDbusError,
                    weak_factory_.GetWeakPtr(), callback));
   }
 
  private:
@@ skipping 34 matching lines @@
   void OnDbusError(const PrinterSetupCallback& cb) {
     // The callback is expected to run on the UI thread.
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     LOG(WARNING) << "Could not contact debugd";
     cb.Run(PrinterSetupResult::kDbusError);
   }
 
   void AddPrinter(const Printer& printer,
                   const std::string& ppd_contents,
                   const PrinterSetupCallback& cb) {
-    auto* client = chromeos::DBusThreadManager::Get()->GetDebugDaemonClient();
+    auto* client = DBusThreadManager::Get()->GetDebugDaemonClient();
 
     client->CupsAddManuallyConfiguredPrinter(
         printer.id(), printer.uri(), ppd_contents,
         base::Bind(&PrinterConfigurerImpl::OnAddedPrinter,
                    weak_factory_.GetWeakPtr(), printer, cb),
         base::Bind(&PrinterConfigurerImpl::OnDbusError,
                    weak_factory_.GetWeakPtr(), cb));
   }
 
   // Executed on component load API finish.
@@ skipping 39 matching lines @@
         LOG(ERROR) << "More than one filter components are requested.";
         cb.Run(PrinterSetupResult::kFatalError);
         return true;
       }
     }
     return false;
   }
 
   void ResolvePpdDone(const Printer& printer,
                       const PrinterSetupCallback& cb,
-                      printing::PpdProvider::CallbackResultCode result,
+                      PpdProvider::CallbackResultCode result,
                       const std::string& ppd_contents,
                       const std::vector<std::string>& ppd_filters) {
     DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
     switch (result) {
-      case chromeos::printing::PpdProvider::SUCCESS:
+      case PpdProvider::SUCCESS:
         DCHECK(!ppd_contents.empty());
         if (!RequiresComponent(printer, cb, ppd_contents, ppd_filters)) {
           AddPrinter(printer, ppd_contents, cb);
         }
         break;
-      case printing::PpdProvider::CallbackResultCode::NOT_FOUND:
+      case PpdProvider::CallbackResultCode::NOT_FOUND:
         cb.Run(PrinterSetupResult::kPpdNotFound);
         break;
-      case printing::PpdProvider::CallbackResultCode::SERVER_ERROR:
+      case PpdProvider::CallbackResultCode::SERVER_ERROR:
         cb.Run(PrinterSetupResult::kPpdUnretrievable);
         break;
-      case printing::PpdProvider::CallbackResultCode::INTERNAL_ERROR:
+      case PpdProvider::CallbackResultCode::INTERNAL_ERROR:
         // TODO(skau): Add kPpdTooLarge when it's reported by the PpdProvider.
         cb.Run(PrinterSetupResult::kFatalError);
         break;
     }
   }
 
-  scoped_refptr<printing::PpdProvider> ppd_provider_;
+  scoped_refptr<PpdProvider> ppd_provider_;
   base::WeakPtrFactory<PrinterConfigurerImpl> weak_factory_;
 };
 
 }  // namespace
 
 // static
 std::unique_ptr<PrinterConfigurer> PrinterConfigurer::Create(Profile* profile) {
   return base::MakeUnique<PrinterConfigurerImpl>(profile);
 }
 
 }  // namespace chromeos