Move chrome.documentScan API to extensions/

extensions/browser/api/document_scan/document_scan_interface_chromeos.cc

 // Copyright 2014 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/extensions/api/document_scan/document_scan_interface_chromeos.h"
+#include "extensions/browser/api/document_scan/document_scan_interface_chromeos.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/lorgnette_manager_client.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace {
 
 const char kImageScanFailedError[] = "Image scan failed";
 const char kScannerImageMimeTypePng[] = "image/png";
 const char kPngImageDataUrlPrefix[] = "data:image/png;base64,";
 
 }  // namespace
 
 namespace extensions {
 
-namespace api {
+namespace core_api {
 
 DocumentScanInterfaceChromeos::DocumentScanInterfaceChromeos()
-    : lorgnette_manager_client_(nullptr) {}
+    : lorgnette_manager_client_(nullptr) {
+}
 
-DocumentScanInterfaceChromeos::~DocumentScanInterfaceChromeos() {}
+DocumentScanInterfaceChromeos::~DocumentScanInterfaceChromeos() {
+}
 
 void DocumentScanInterfaceChromeos::ListScanners(
     const ListScannersResultsCallback& callback) {
-  GetLorgnetteManagerClient()->ListScanners(base::Bind(
-           &DocumentScanInterfaceChromeos::OnScannerListReceived,
-           base::Unretained(this),
-           callback));
+  GetLorgnetteManagerClient()->ListScanners(
+      base::Bind(&DocumentScanInterfaceChromeos::OnScannerListReceived,
+                 base::Unretained(this), callback));
 }
 
 void DocumentScanInterfaceChromeos::OnScannerListReceived(
     const ListScannersResultsCallback& callback,
     bool succeeded,
-    const chromeos::LorgnetteManagerClient::ScannerTable &scanners) {
+    const chromeos::LorgnetteManagerClient::ScannerTable& scanners) {
   std::vector<ScannerDescription> scanner_descriptions;
   for (const auto& scanner : scanners) {
     ScannerDescription description;
     description.name = scanner.first;
-    const auto &entry = scanner.second;
+    const auto& entry = scanner.second;
     auto info_it = entry.find(lorgnette::kScannerPropertyManufacturer);
     if (info_it != entry.end()) {
       description.manufacturer = info_it->second;
     }
     info_it = entry.find(lorgnette::kScannerPropertyModel);
     if (info_it != entry.end()) {
       description.model = info_it->second;
     }
     info_it = entry.find(lorgnette::kScannerPropertyType);
     if (info_it != entry.end()) {
@@ skipping 26 matching lines @@
       break;
   }
 
   if (resolution_dpi != 0) {
     properties.resolution_dpi = resolution_dpi;
   }
 
   GetLorgnetteManagerClient()->ScanImageToString(
       scanner_name, properties,
       base::Bind(&DocumentScanInterfaceChromeos::OnScanCompleted,
-                 base::Unretained(this),
-                 callback));
+                 base::Unretained(this), callback));
 }
 
 void DocumentScanInterfaceChromeos::OnScanCompleted(
-    const ScanResultsCallback &callback,
+    const ScanResultsCallback& callback,
     bool succeeded,
     const std::string& image_data) {
   VLOG(1) << "ScanImage returns " << succeeded;
   std::string error_string;
   if (!succeeded) {
     error_string = kImageScanFailedError;
   }
 
   std::string image_base64;
   base::Base64Encode(image_data, &image_base64);
   std::string image_url(std::string(kPngImageDataUrlPrefix) + image_base64);
 
   callback.Run(image_url, kScannerImageMimeTypePng, error_string);
 }
 
 chromeos::LorgnetteManagerClient*
-    DocumentScanInterfaceChromeos::GetLorgnetteManagerClient() {
+DocumentScanInterfaceChromeos::GetLorgnetteManagerClient() {
   if (!lorgnette_manager_client_) {
     lorgnette_manager_client_ =
         chromeos::DBusThreadManager::Get()->GetLorgnetteManagerClient();
     CHECK(lorgnette_manager_client_);
   }
   return lorgnette_manager_client_;
 }
 
 // static
-DocumentScanInterface *DocumentScanInterface::CreateInstance() {
+DocumentScanInterface* DocumentScanInterface::CreateInstance() {
   return new DocumentScanInterfaceChromeos();
 }
 
-}  // namespace api
+}  // namespace core_api
 
 }  // namespace extensions