Instead of ArrayBuffer, pass blob with printerProvider.onPrintRequested

extensions/browser/api/printer_provider/printer_provider_api.cc

 // Copyright 2015 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 "extensions/browser/api/printer_provider/printer_provider_api.h"
 
 #include <map>
 #include <set>
 #include <utility>
 #include <vector>
@@ skipping 139 matching lines @@
 
 // Keeps track of pending chrome.printerProvider.ontPrintRequested requests
 // for an extension.
 class PendingPrintRequests {
  public:
   PendingPrintRequests();
   ~PendingPrintRequests();
 
   // Adds a new request to the set. Only information needed is the callback
   // associated with the request. Returns the id assigned to the request.
-  int Add(const PrinterProviderAPI::PrintCallback& callback);
+  int Add(const PrinterProviderPrintJob& job,
+          const PrinterProviderAPI::PrintCallback& callback);
+
+  // Gets print job associated with a request.
+  const PrinterProviderPrintJob* GetPrintJob(int request_id) const;
 
   // Completes the request with the provided request id. It runs the request
   // callback and removes the request from the set.
   bool Complete(int request_id, bool success, const std::string& result);
 
   // Runs all pending callbacks with ERROR_FAILED and clears the set of
   // pending requests.
   void FailAll();
 
  private:
+  struct PrintRequest {
+    PrinterProviderAPI::PrintCallback callback;
+    PrinterProviderPrintJob job;
+  };
+
   int last_request_id_;
-  std::map<int, PrinterProviderAPI::PrintCallback> pending_requests_;
+  std::map<int, PrintRequest> pending_requests_;
 };
 
 // Implements chrome.printerProvider API events.
 class PrinterProviderAPIImpl : public PrinterProviderAPI,
                                public PrinterProviderInternalAPIObserver,
                                public ExtensionRegistryObserver {
  public:
   explicit PrinterProviderAPIImpl(content::BrowserContext* browser_context);
   ~PrinterProviderAPIImpl() override;
 
  private:
   // PrinterProviderAPI implementation:
   void DispatchGetPrintersRequested(
       const PrinterProviderAPI::GetPrintersCallback& callback) override;
   void DispatchGetCapabilityRequested(
       const std::string& printer_id,
       const PrinterProviderAPI::GetCapabilityCallback& callback) override;
   void DispatchPrintRequested(
       const PrinterProviderPrintJob& job,
       const PrinterProviderAPI::PrintCallback& callback) override;
+  const PrinterProviderPrintJob* GetPrintJob(const Extension* extension,
+                                             int request_id) const override;
 
   // PrinterProviderInternalAPIObserver implementation:
   void OnGetPrintersResult(
       const Extension* extension,
       int request_id,
       const PrinterProviderInternalAPIObserver::PrinterInfoVector& result)
       override;
   void OnGetCapabilityResult(const Extension* extension,
                              int request_id,
                              const base::DictionaryValue& result) override;
@@ skipping 140 matching lines @@
   pending_requests_.clear();
 }
 
 PendingPrintRequests::PendingPrintRequests() : last_request_id_(0) {
 }
 
 PendingPrintRequests::~PendingPrintRequests() {
 }
 
 int PendingPrintRequests::Add(
+    const PrinterProviderPrintJob& job,
     const PrinterProviderAPI::PrintCallback& callback) {
-  pending_requests_[++last_request_id_] = callback;
+  PrintRequest request;
+  request.callback = callback;
+  request.job = job;
+  pending_requests_[++last_request_id_] = request;
   return last_request_id_;
 }
 
 bool PendingPrintRequests::Complete(int request_id,
                                     bool success,
                                     const std::string& response) {
   auto it = pending_requests_.find(request_id);
   if (it == pending_requests_.end())
     return false;
 
-  PrinterProviderAPI::PrintCallback callback = it->second;
+  PrinterProviderAPI::PrintCallback callback = it->second.callback;
   pending_requests_.erase(it);
 
   callback.Run(success, response);
   return true;
 }
 
+const PrinterProviderPrintJob* PendingPrintRequests::GetPrintJob(
+    int request_id) const {
+  auto it = pending_requests_.find(request_id);
+  if (it == pending_requests_.end())
+    return nullptr;
+
+  return &it->second.job;
+}
+
 void PendingPrintRequests::FailAll() {
   for (auto& request : pending_requests_)
-    request.second.Run(false, PrinterProviderAPI::GetDefaultPrintError());
+    request.second.callback.Run(false,
+                                PrinterProviderAPI::GetDefaultPrintError());
   pending_requests_.clear();
 }
 
 PrinterProviderAPIImpl::PrinterProviderAPIImpl(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context),
       internal_api_observer_(this),
       extension_registry_observer_(this) {
   internal_api_observer_.Add(
       PrinterProviderInternalAPI::GetFactoryInstance()->Get(browser_context));
@@ skipping 92 matching lines @@
   scoped_ptr<base::Value> ticket_value(deserializer.Deserialize(NULL, NULL));
   if (!ticket_value ||
       !core_api::printer_provider::PrintJob::Ticket::Populate(
           *ticket_value, &print_job.ticket)) {
     callback.Run(false,
                  core_api::printer_provider::ToString(
                      core_api::printer_provider::PRINT_ERROR_INVALID_TICKET));
     return;
   }
 
-  // TODO(tbarzic): Figure out how to support huge documents.
-  if (job.document_bytes->size() > PrinterProviderAPI::kMaxDocumentSize) {
-    callback.Run(false,
-                 core_api::printer_provider::ToString(
-                     core_api::printer_provider::PRINT_ERROR_INVALID_DATA));
-    return;
-  }
-
   print_job.content_type = job.content_type;
-  print_job.document = std::vector<char>(
-      job.document_bytes->front(),
-      job.document_bytes->front() + job.document_bytes->size());
-
-  int request_id = pending_print_requests_[extension_id].Add(callback);
+  int request_id = pending_print_requests_[extension_id].Add(job, callback);
 
   scoped_ptr<base::ListValue> internal_args(new base::ListValue);
   // Request id is not part of the public API and it will be massaged out in
   // custom bindings.
   internal_args->AppendInteger(request_id);
   internal_args->Append(print_job.ToValue().release());
   scoped_ptr<Event> event(
       new Event(core_api::printer_provider::OnPrintRequested::kEventName,
                 internal_args.Pass()));
+  event_router->DispatchEventToExtension(extension_id, event.Pass());
+}
 
-  event_router->DispatchEventToExtension(extension_id, event.Pass());
+const PrinterProviderPrintJob* PrinterProviderAPIImpl::GetPrintJob(
+    const Extension* extension,
+    int request_id) const {
+  auto it = pending_print_requests_.find(extension->id());
+  if (it == pending_print_requests_.end())
+    return nullptr;
+  return it->second.GetPrintJob(request_id);
 }
 
 void PrinterProviderAPIImpl::OnGetPrintersResult(
     const Extension* extension,
     int request_id,
     const PrinterProviderInternalAPIObserver::PrinterInfoVector& result) {
   base::ListValue printer_list;
 
   // Update some printer description properties to better identify the extension
   // managing the printer.
@@ skipping 88 matching lines @@
   return new PrinterProviderAPIImpl(context);
 }
 
 // static
 std::string PrinterProviderAPI::GetDefaultPrintError() {
   return core_api::printer_provider_internal::ToString(
       core_api::printer_provider_internal::PRINT_ERROR_FAILED);
 }
 
 }  // namespace extensions