Implement a JavaScript API for document scanning

chrome/browser/extensions/api/document_scan/document_scan_api.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_api.h"
+
+#include <algorithm>
+
+#include "content/public/browser/browser_thread.h"
+#include "extensions/browser/extension_system.h"
+
+using content::BrowserThread;
+using std::string;
+using std::vector;

[asargent_no_longer_on_chrome, 2014/10/29 23:05:21]

nit: having using statements for std:: members is uncommon in this area of code
; it might be best to omit them

(similar for occurrences elsewhere in CL)

[Paul Stewart, 2014/10/30 06:31:51]

Done.

+
+namespace {
+
+const char kScannerNotAvailable[] = "Scanner not available";
+const char kUserGestureRequiredError[] =
+    "User gesture required to perform scan";
+}  // namespace
+
+namespace extensions {
+
+namespace api {
+
+DocumentScanScanFunction::DocumentScanScanFunction()
+    : document_scan_interface_(DocumentScanInterface::CreateInstance()) {}
+
+DocumentScanScanFunction::~DocumentScanScanFunction() {}
+
+bool DocumentScanScanFunction::Prepare() {
+  set_work_thread_id(BrowserThread::FILE);
+  params_ = document_scan::Scan::Params::Create(*args_);
+  EXTENSION_FUNCTION_VALIDATE(params_.get());
+  return true;
+}
+
+void DocumentScanScanFunction::AsyncWorkStart() {
+  if (!user_gesture()) {
+    error_ = kUserGestureRequiredError;
+    AsyncWorkCompleted();
+    return;
+  }
+
+  // Add a reference, which is balanced in OnScannerListReceived to keep the
+  // object around and allow the callback to be invoked.
+  AddRef();
+
+  document_scan_interface_->ListScanners(
+      base::Bind(&DocumentScanScanFunction::OnScannerListReceived,
+                 base::Unretained(this)));
+}
+
+void DocumentScanScanFunction::OnScannerListReceived(
+    const vector<DocumentScanInterface::ScannerDescription>&
+        scanner_descriptions,
+    const string& error) {
+  vector<DocumentScanInterface::ScannerDescription>::const_iterator
+      scanner_i = scanner_descriptions.begin();
+  if (params_->options.mime_types) {
+    vector<string>& mime_types = *params_->options.mime_types.get();
+    for (; scanner_i != scanner_descriptions.end(); ++scanner_i) {
+      if (std::find(mime_types.begin(), mime_types.end(),
+                    scanner_i->image_mime_type) != mime_types.end()) {
+        break;
+      }
+    }
+  }
+
+  if (scanner_i == scanner_descriptions.end()) {
+    error_ = kScannerNotAvailable;
+    AsyncWorkCompleted();
+
+    // Balance the AddRef in AsyncWorkStart().
+    Release();
+    return;
+  }
+
+  // TODO(pstew): Display a user interface for choosing a scanner.
+  // This is where the scan mode, DPI, etc, would be specified.
+
+  document_scan_interface_->Scan(
+      scanner_i->name,
+      DocumentScanInterface::kScanModeColor,
+      0,
+      base::Bind(&DocumentScanScanFunction::OnResultsReceived,
+                 base::Unretained(this)));
+}
+
+void DocumentScanScanFunction::OnResultsReceived(
+    const string& scanned_image, const string& mime_type, const string& error) {
+  // TODO(pstew): Display received scan in the UI and confirm that this
+  // scan should be sent to the caller.  If this is a multi-page scan,
+  // provide a means for adding additional scanned images up to the
+  // requested limit.
+
+  if (error.empty()) {
+    document_scan::ScanResults scan_results;
+    if (!scanned_image.empty()) {
+      scan_results.data_urls.push_back(scanned_image);
+    }
+    scan_results.mime_type = mime_type;
+    results_ = document_scan::Scan::Results::Create(scan_results);
+  }
+  error_ = error;
+  AsyncWorkCompleted();
+
+  // Balance the AddRef in AsyncWorkStart().
+  Release();
+}
+
+bool DocumentScanScanFunction::Respond() {
+  return error_.empty();
+}
+
+}  // namespace api
+
+}  // namespace extensions