src/chrome/browser/extensions/api/document_scan/document_scan_interface_chromeos.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/extensions/api/document_scan/document_scan_interface_chromeos.h"
   6
   7 #include "base/base64.h"
   8 #include "base/bind.h"
   9 #include "chromeos/dbus/dbus_thread_manager.h"
  10 #include "chromeos/dbus/lorgnette_manager_client.h"
  11 #include "third_party/cros_system_api/dbus/service_constants.h"
  12
  13 namespace {
  14
  15 const char kImageScanFailedError[] = "Image scan failed";
  16 const char kScannerImageMimeTypePng[] = "image/png";
  17 const char kPngImageDataUrlPrefix[] = "data:image/png;base64,";
  18
  19 }  // namespace
  20
  21 namespace extensions {
  22
  23 namespace api {
  24
  25 DocumentScanInterfaceChromeos::DocumentScanInterfaceChromeos()
  26     : lorgnette_manager_client_(nullptr) {}
  27
  28 DocumentScanInterfaceChromeos::~DocumentScanInterfaceChromeos() {}
  29
  30 void DocumentScanInterfaceChromeos::ListScanners(
  31     const ListScannersResultsCallback& callback) {
  32   GetLorgnetteManagerClient()->ListScanners(base::Bind(
  33            &DocumentScanInterfaceChromeos::OnScannerListReceived,
  34            base::Unretained(this),
  35            callback));
  36 }
  37
  38 void DocumentScanInterfaceChromeos::OnScannerListReceived(
  39     const ListScannersResultsCallback& callback,
  40     bool succeeded,
  41     const chromeos::LorgnetteManagerClient::ScannerTable &scanners) {
  42   std::vector<ScannerDescription> scanner_descriptions;
  43   for (const auto& scanner : scanners) {
  44     ScannerDescription description;
  45     description.name = scanner.first;
  46     const auto &entry = scanner.second;
  47     auto info_it = entry.find(lorgnette::kScannerPropertyManufacturer);
  48     if (info_it != entry.end()) {
  49       description.manufacturer = info_it->second;
  50     }
  51     info_it = entry.find(lorgnette::kScannerPropertyModel);
  52     if (info_it != entry.end()) {
  53       description.model = info_it->second;
  54     }
  55     info_it = entry.find(lorgnette::kScannerPropertyType);
  56     if (info_it != entry.end()) {
  57       description.scanner_type = info_it->second;
  58     }
  59     description.image_mime_type = kScannerImageMimeTypePng;
  60     scanner_descriptions.push_back(description);
  61   }
  62   const std::string kNoError;
  63   callback.Run(scanner_descriptions, kNoError);
  64 }
  65
  66 void DocumentScanInterfaceChromeos::Scan(const std::string& scanner_name,
  67                                          ScanMode mode,
  68                                          int resolution_dpi,
  69                                          const ScanResultsCallback& callback) {
  70   VLOG(1) << "Choosing scanner " << scanner_name;
  71   chromeos::LorgnetteManagerClient::ScanProperties properties;
  72   switch (mode) {
  73     case kScanModeColor:
  74       properties.mode = lorgnette::kScanPropertyModeColor;
  75       break;
  76
  77     case kScanModeGray:
  78       properties.mode = lorgnette::kScanPropertyModeGray;
  79       break;
  80
  81     case kScanModeLineart:
  82       properties.mode = lorgnette::kScanPropertyModeLineart;
  83       break;
  84   }
  85
  86   if (resolution_dpi != 0) {
  87     properties.resolution_dpi = resolution_dpi;
  88   }
  89
  90   GetLorgnetteManagerClient()->ScanImageToString(
  91       scanner_name, properties,
  92       base::Bind(&DocumentScanInterfaceChromeos::OnScanCompleted,
  93                  base::Unretained(this),
  94                  callback));
  95 }
  96
  97 void DocumentScanInterfaceChromeos::OnScanCompleted(
  98     const ScanResultsCallback &callback,
  99     bool succeeded,
 100     const std::string& image_data) {
 101   VLOG(1) << "ScanImage returns " << succeeded;
 102   std::string error_string;
 103   if (!succeeded) {
 104     error_string = kImageScanFailedError;
 105   }
 106
 107   std::string image_base64;
 108   base::Base64Encode(image_data, &image_base64);
 109   std::string image_url(std::string(kPngImageDataUrlPrefix) + image_base64);
 110
 111   callback.Run(image_url, kScannerImageMimeTypePng, error_string);
 112 }
 113
 114 chromeos::LorgnetteManagerClient*
 115     DocumentScanInterfaceChromeos::GetLorgnetteManagerClient() {
 116   if (!lorgnette_manager_client_) {
 117     lorgnette_manager_client_ =
 118         chromeos::DBusThreadManager::Get()->GetLorgnetteManagerClient();
 119     CHECK(lorgnette_manager_client_);
 120   }
 121   return lorgnette_manager_client_;
 122 }
 123
 124 // static
 125 DocumentScanInterface *DocumentScanInterface::CreateInstance() {
 126   return new DocumentScanInterfaceChromeos();
 127 }
 128
 129 }  // namespace api
 130
 131 }  // namespace extensions