Make chromeos CUPS printing code namespaces consistent.

chrome/browser/chromeos/printing/synced_printers_manager.cc

 // Copyright 2016 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/synced_printers_manager.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 18 matching lines @@
 namespace {
 
 // Adds |printer| with |id| to prefs.  Returns true if the printer is new,
 // false for an update.
 bool UpdatePrinterPref(PrintersSyncBridge* sync_bridge,
                        const std::string& id,
                        const Printer& printer) {
   base::Optional<sync_pb::PrinterSpecifics> specifics =
       sync_bridge->GetPrinter(id);
   if (!specifics.has_value()) {
-    sync_bridge->AddPrinter(printing::PrinterToSpecifics(printer));
+    sync_bridge->AddPrinter(PrinterToSpecifics(printer));
     return true;
   }
 
   // Preserve fields in the proto which we don't understand.
   std::unique_ptr<sync_pb::PrinterSpecifics> updated_printer =
       base::MakeUnique<sync_pb::PrinterSpecifics>(*specifics);
-  printing::MergePrinterToSpecifics(printer, updated_printer.get());
+  MergePrinterToSpecifics(printer, updated_printer.get());
   sync_bridge->AddPrinter(std::move(updated_printer));
 
   return false;
 }
 
 }  // anonymous namespace
 
 SyncedPrintersManager::SyncedPrintersManager(
     Profile* profile,
     std::unique_ptr<PrintersSyncBridge> sync_bridge)
@@ skipping 16 matching lines @@
   registry->RegisterListPref(prefs::kRecommendedNativePrinters);
 }
 
 std::vector<std::unique_ptr<Printer>> SyncedPrintersManager::GetPrinters()
     const {
   std::vector<std::unique_ptr<Printer>> printers;
 
   std::vector<sync_pb::PrinterSpecifics> values =
       sync_bridge_->GetAllPrinters();
   for (const auto& value : values) {
-    printers.push_back(printing::SpecificsToPrinter(value));
+    printers.push_back(SpecificsToPrinter(value));
   }
 
   return printers;
 }
 
 std::vector<std::unique_ptr<Printer>>
 SyncedPrintersManager::GetRecommendedPrinters() const {
   std::vector<std::unique_ptr<Printer>> printers;
 
   for (const std::string& key : recommended_printer_ids_) {
@@ skipping 11 matching lines @@
   // check for a policy printer first
   const auto& policy_printers = recommended_printers_;
   auto found = policy_printers.find(printer_id);
   if (found != policy_printers.end()) {
     // Copy a printer.
     return base::MakeUnique<Printer>(*(found->second));
   }
 
   base::Optional<sync_pb::PrinterSpecifics> printer =
       sync_bridge_->GetPrinter(printer_id);
-  return printer.has_value() ? printing::SpecificsToPrinter(*printer) : nullptr;
+  return printer.has_value() ? SpecificsToPrinter(*printer) : nullptr;
 }
 
 void SyncedPrintersManager::RegisterPrinter(std::unique_ptr<Printer> printer) {
   if (printer->id().empty()) {
     printer->set_id(base::GenerateGUID());
   }
 
   DCHECK_EQ(Printer::SRC_USER_PREFS, printer->source());
   bool new_printer =
       UpdatePrinterPref(sync_bridge_.get(), printer->id(), *printer);
 
   if (new_printer) {
     for (Observer& obs : observers_) {
       obs.OnPrinterAdded(*printer);
     }
   } else {
     for (Observer& obs : observers_) {
       obs.OnPrinterUpdated(*printer);
     }
   }
 }
 
 bool SyncedPrintersManager::RemovePrinter(const std::string& printer_id) {
   DCHECK(!printer_id.empty());
 
   base::Optional<sync_pb::PrinterSpecifics> printer =
       sync_bridge_->GetPrinter(printer_id);
   bool success = false;
   if (printer.has_value()) {
-    std::unique_ptr<Printer> p = printing::SpecificsToPrinter(*printer);
+    std::unique_ptr<Printer> p = SpecificsToPrinter(*printer);
     success = sync_bridge_->RemovePrinter(p->id());
     if (success) {
       for (Observer& obs : observers_) {
         obs.OnPrinterRemoved(*p);
       }
     }
   } else {
     LOG(WARNING) << "Could not find printer" << printer_id;
   }
 
@@ skipping 38 matching lines @@
     if (!printer_dictionary) {
       LOG(WARNING) << "Ignoring invalid printer.  Invalid JSON object: "
                    << printer_json;
       continue;
     }
 
     // Policy printers don't have id's but the ids only need to be locally
     // unique so we'll hash the record.  This will not collide with the UUIDs
     // generated for user entries.
     std::string id = base::MD5String(printer_json);
-    printer_dictionary->SetString(printing::kPrinterId, id);
+    printer_dictionary->SetString(kPrinterId, id);
 
     if (base::ContainsKey(new_printers, id)) {
       // Skip duplicated entries.
       LOG(WARNING) << "Duplicate printer ignored.";
       continue;
     }
 
     new_ids.push_back(id);
     // Move existing printers, create othewise.
     auto old = recommended_printers_.find(id);
     if (old != recommended_printers_.end()) {
       new_printers[id] = std::move(old->second);
     } else {
       auto printer =
-          printing::RecommendedPrinterToPrinter(*printer_dictionary, timestamp);
+          RecommendedPrinterToPrinter(*printer_dictionary, timestamp);
       printer->set_source(Printer::SRC_POLICY);
 
       new_printers[id] = std::move(printer);
     }
   }
 
   // Objects not in the most recent update get deallocated after method exit.
   recommended_printer_ids_.swap(new_ids);
   recommended_printers_.swap(new_printers);
 }
 
 void SyncedPrintersManager::PrinterInstalled(const Printer& printer) {
   DCHECK(!printer.last_updated().is_null());
   installed_printer_timestamps_[printer.id()] = printer.last_updated();
 }
 
 bool SyncedPrintersManager::IsConfigurationCurrent(
     const Printer& printer) const {
   auto found = installed_printer_timestamps_.find(printer.id());
   if (found == installed_printer_timestamps_.end())
     return false;
 
   return found->second == printer.last_updated();
 }
 
 }  // namespace chromeos