Instead of ArrayBuffer, pass blob with printerProvider.onPrintRequested

chrome/browser/ui/webui/print_preview/extension_printer_handler_unittest.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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
@@ skipping 97 matching lines @@
 
 // Print ticket that has duplex parameter set.
 const char kPrintTicketWithDuplex[] =
     "{"
     "  \"version\": \"1.0\","
     "  \"print\": {"
     "    \"duplex\": {\"type\": \"LONG_EDGE\"}"
     "  }"
     "}";
 
-// Suffix appended to document data by fake PWGRasterConverter.
-const char kPWGConversionSuffix[] = "_converted";
-
 const char kContentTypePDF[] = "application/pdf";
 const char kContentTypePWG[] = "image/pwg-raster";
 
 // Print request status considered to be successful by fake PrinterProviderAPI.
 const char kPrintRequestSuccess[] = "OK";
 
 // Used as a callback to StartGetPrinters in tests.
 // Increases |*call_count| and records values returned by StartGetPrinters.
 void RecordPrinterList(size_t* call_count,
                        scoped_ptr<base::ListValue>* printers_out,
@@ skipping 55 matching lines @@
   if (!deserialized)
     return scoped_ptr<base::DictionaryValue>();
   base::DictionaryValue* dictionary;
   if (!deserialized->GetAsDictionary(&dictionary)) {
     *error = "Value is not a dictionary.";
     return scoped_ptr<base::DictionaryValue>();
   }
   return scoped_ptr<base::DictionaryValue>(dictionary->DeepCopy());
 }
 
+std::string RefCountedMemoryToString(
+    const scoped_refptr<base::RefCountedMemory>& memory) {
+  return std::string(memory->front_as<char>(), memory->size());
+}
+
 // Fake PWGRasterconverter used in the tests.
 class FakePWGRasterConverter : public PWGRasterConverter {
  public:
   FakePWGRasterConverter() : fail_conversion_(false), initialized_(false) {}
   ~FakePWGRasterConverter() override = default;
 
-  // PWGRasterConverter implementation.
-  // It writes |data| to a temp file, appending it |kPWGConversionSuffix|.
+  // PWGRasterConverter implementation. It writes |data| to a temp file.
   // Also, remembers conversion and bitmap settings passed into the method.
   void Start(base::RefCountedMemory* data,
              const printing::PdfRenderSettings& conversion_settings,
              const printing::PwgRasterSettings& bitmap_settings,
              const ResultCallback& callback) override {
     if (fail_conversion_) {
       callback.Run(false, base::FilePath());
       return;
     }
 
     if (!initialized_ && !temp_dir_.CreateUniqueTempDir()) {
       ADD_FAILURE() << "Unable to create target dir for cenverter";
       callback.Run(false, base::FilePath());
       return;
     }
 
     initialized_ = true;
 
+    path_ = temp_dir_.path().AppendASCII("output.pwg");
     std::string data_str(data->front_as<char>(), data->size());
-    data_str.append(kPWGConversionSuffix);
-    base::FilePath target_path = temp_dir_.path().AppendASCII("output.pwg");
-    int written = WriteFile(target_path, data_str.c_str(), data_str.size());
+    int written = WriteFile(path_, data_str.c_str(), data_str.size());
     if (written != static_cast<int>(data_str.size())) {
       ADD_FAILURE() << "Failed to write pwg raster file.";
       callback.Run(false, base::FilePath());
       return;
     }
 
     conversion_settings_ = conversion_settings;
     bitmap_settings_ = bitmap_settings;
 
-    callback.Run(true, target_path);
+    callback.Run(true, path_);
   }
 
   // Makes |Start| method always return an error.
   void FailConversion() { fail_conversion_ = true; }
 
+  const base::FilePath& path() { return path_; }
   const printing::PdfRenderSettings& conversion_settings() const {
     return conversion_settings_;
   }
 
   const printing::PwgRasterSettings& bitmap_settings() const {
     return bitmap_settings_;
   }
 
  private:
   base::ScopedTempDir temp_dir_;
 
+  base::FilePath path_;
   printing::PdfRenderSettings conversion_settings_;
   printing::PwgRasterSettings bitmap_settings_;
   bool fail_conversion_;
   bool initialized_;
 
   DISALLOW_COPY_AND_ASSIGN(FakePWGRasterConverter);
 };
 
-// Copy of data contained in print job passed to |DispatchPrintRequested|.
-struct PrintJobParams {
-  std::string printer_id;
-  std::string ticket;
-  std::string content_type;
-  std::string document;
-};
-
 // Information about received print requests.
 struct PrintRequestInfo {
   PrinterProviderAPI::PrintCallback callback;
-  PrintJobParams params;
+  PrinterProviderPrintJob job;
 };
 
 // Fake PrinterProviderAPI used in tests.
 // It caches requests issued to API and exposes methods to trigger their
 // callbacks.
 class FakePrinterProviderAPI : public PrinterProviderAPI {
  public:
   FakePrinterProviderAPI() = default;
   ~FakePrinterProviderAPI() override = default;
 
   void DispatchGetPrintersRequested(
       const PrinterProviderAPI::GetPrintersCallback& callback) override {
     pending_printers_callbacks_.push_back(callback);
   }
 
   void DispatchGetCapabilityRequested(
       const std::string& destination_id,
       const PrinterProviderAPI::GetCapabilityCallback& callback) override {
     pending_capability_callbacks_.push_back(base::Bind(callback));
   }
 
   void DispatchPrintRequested(
       const PrinterProviderPrintJob& job,
       const PrinterProviderAPI::PrintCallback& callback) override {
     PrintRequestInfo request_info;
     request_info.callback = callback;
-
-    request_info.params.printer_id = job.printer_id;
-    request_info.params.ticket = job.ticket_json;
-    request_info.params.content_type = job.content_type;
-    request_info.params.document = std::string(
-        job.document_bytes->front_as<char>(), job.document_bytes->size());
+    request_info.job = job;
 
     pending_print_requests_.push_back(request_info);
   }
 
   size_t pending_get_printers_count() const {
     return pending_printers_callbacks_.size();
   }
 
+  const PrinterProviderPrintJob* GetPrintJob(
+      const extensions::Extension* extension,
+      int request_id) const override {
+    ADD_FAILURE() << "Not reached";
+    return nullptr;
+  }
+
   void TriggerNextGetPrintersCallback(const base::ListValue& printers,
                                       bool done) {
     ASSERT_GT(pending_get_printers_count(), 0u);
     pending_printers_callbacks_[0].Run(printers, done);
     pending_printers_callbacks_.erase(pending_printers_callbacks_.begin());
   }
 
   size_t pending_get_capability_count() const {
     return pending_capability_callbacks_.size();
   }
 
   void TriggerNextGetCapabilityCallback(
       const base::DictionaryValue& description) {
     ASSERT_GT(pending_get_capability_count(), 0u);
     pending_capability_callbacks_[0].Run(description);
     pending_capability_callbacks_.erase(pending_capability_callbacks_.begin());
   }
 
   size_t pending_print_count() const { return pending_print_requests_.size(); }
 
-  const PrintJobParams* GetNextPendingPrintJob() const {
+  const PrinterProviderPrintJob* GetNextPendingPrintJob() const {
     EXPECT_GT(pending_print_count(), 0u);
     if (pending_print_count() == 0)
       return NULL;
-    return &pending_print_requests_[0].params;
+    return &pending_print_requests_[0].job;
   }
 
   void TriggerNextPrintCallback(const std::string& result) {
     ASSERT_GT(pending_print_count(), 0u);
     pending_print_requests_[0].callback.Run(result == kPrintRequestSuccess,
                                             result);
     pending_print_requests_.erase(pending_print_requests_.begin());
   }
 
  private:
@@ skipping 173 matching lines @@
   extension_printer_handler_->StartPrint(
       kPrinterId, kPdfSupportedPrinter, kEmptyPrintTicket, gfx::Size(100, 100),
       print_data,
       base::Bind(&RecordPrintResult, &call_count, &success, &status));
 
   EXPECT_EQ(0u, call_count);
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_print_count());
 
-  const PrintJobParams* print_job = fake_api->GetNextPendingPrintJob();
+  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
   ASSERT_TRUE(print_job);
 
   EXPECT_EQ(kPrinterId, print_job->printer_id);
-  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket);
+  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket_json);
   EXPECT_EQ(kContentTypePDF, print_job->content_type);
-  EXPECT_EQ(print_data->data(), print_job->document);
+  EXPECT_TRUE(print_job->document_path.empty());
+  ASSERT_TRUE(print_job->document_bytes);
+  EXPECT_EQ(print_data->data(),
+            RefCountedMemoryToString(print_job->document_bytes));
 
   fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_TRUE(success);
   EXPECT_EQ(kPrintRequestSuccess, status);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, Print_Pdf_Reset) {
   size_t call_count = 0;
@@ skipping 34 matching lines @@
       kPrinterId, kAllContentTypesSupportedPrinter, kEmptyPrintTicket,
       gfx::Size(100, 100), print_data,
       base::Bind(&RecordPrintResult, &call_count, &success, &status));
 
   EXPECT_EQ(0u, call_count);
 
   FakePrinterProviderAPI* fake_api = GetPrinterProviderAPI();
   ASSERT_TRUE(fake_api);
   ASSERT_EQ(1u, fake_api->pending_print_count());
 
-  const PrintJobParams* print_job = fake_api->GetNextPendingPrintJob();
+  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
   ASSERT_TRUE(print_job);
 
   EXPECT_EQ(kPrinterId, print_job->printer_id);
-  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket);
+  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket_json);
   EXPECT_EQ(kContentTypePDF, print_job->content_type);
-  EXPECT_EQ(print_data->data(), print_job->document);
+  EXPECT_TRUE(print_job->document_path.empty());
+  ASSERT_TRUE(print_job->document_bytes);
+  EXPECT_EQ(print_data->data(),
+            RefCountedMemoryToString(print_job->document_bytes));
 
   fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_TRUE(success);
   EXPECT_EQ(kPrintRequestSuccess, status);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, Print_Pwg) {
   size_t call_count = 0;
@@ skipping 21 matching lines @@
             pwg_raster_converter_->bitmap_settings().odd_page_transform);
   EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_FALSE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
 
   EXPECT_EQ(printing::kDefaultPdfDpi,
             pwg_raster_converter_->conversion_settings().dpi());
   EXPECT_TRUE(pwg_raster_converter_->conversion_settings().autorotate());
   EXPECT_EQ("0,0 208x416",  // vertically_oriented_size  * dpi / points_per_inch
             pwg_raster_converter_->conversion_settings().area().ToString());
 
-  const PrintJobParams* print_job = fake_api->GetNextPendingPrintJob();
+  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
   ASSERT_TRUE(print_job);
 
   EXPECT_EQ(kPrinterId, print_job->printer_id);
-  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket);
+  EXPECT_EQ(kEmptyPrintTicket, print_job->ticket_json);
   EXPECT_EQ(kContentTypePWG, print_job->content_type);
-  EXPECT_EQ(print_data->data() + kPWGConversionSuffix, print_job->document);
+  EXPECT_FALSE(print_job->document_bytes);
+  EXPECT_FALSE(print_job->document_path.empty());
+  EXPECT_EQ(pwg_raster_converter_->path(), print_job->document_path);
+  EXPECT_EQ(static_cast<int64_t>(print_data->size()),
+            print_job->file_info.size);
 
   fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_TRUE(success);
   EXPECT_EQ(kPrintRequestSuccess, status);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_NonDefaultSettings) {
   size_t call_count = 0;
@@ skipping 21 matching lines @@
             pwg_raster_converter_->bitmap_settings().odd_page_transform);
   EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().rotate_all_pages);
   EXPECT_TRUE(pwg_raster_converter_->bitmap_settings().reverse_page_order);
 
   EXPECT_EQ(200,  // max(vertical_dpi, horizontal_dpi)
             pwg_raster_converter_->conversion_settings().dpi());
   EXPECT_TRUE(pwg_raster_converter_->conversion_settings().autorotate());
   EXPECT_EQ("0,0 138x277",  // vertically_oriented_size  * dpi / points_per_inch
             pwg_raster_converter_->conversion_settings().area().ToString());
 
-  const PrintJobParams* print_job = fake_api->GetNextPendingPrintJob();
+  const PrinterProviderPrintJob* print_job = fake_api->GetNextPendingPrintJob();
   ASSERT_TRUE(print_job);
 
   EXPECT_EQ(kPrinterId, print_job->printer_id);
-  EXPECT_EQ(kPrintTicketWithDuplex, print_job->ticket);
+  EXPECT_EQ(kPrintTicketWithDuplex, print_job->ticket_json);
   EXPECT_EQ(kContentTypePWG, print_job->content_type);
-  EXPECT_EQ(print_data->data() + kPWGConversionSuffix, print_job->document);
+  EXPECT_FALSE(print_job->document_bytes);
+  EXPECT_FALSE(print_job->document_path.empty());
+  EXPECT_EQ(pwg_raster_converter_->path(), print_job->document_path);
+  EXPECT_EQ(static_cast<int64_t>(print_data->size()),
+            print_job->file_info.size);
 
   fake_api->TriggerNextPrintCallback(kPrintRequestSuccess);
 
   EXPECT_EQ(1u, call_count);
   EXPECT_TRUE(success);
   EXPECT_EQ(kPrintRequestSuccess, status);
 }
 
 TEST_F(ExtensionPrinterHandlerTest, Print_Pwg_Reset) {
   size_t call_count = 0;
@@ skipping 58 matching lines @@
   extension_printer_handler_->StartPrint(
       kPrinterId, kPWGRasterOnlyPrinterSimpleDescription, kEmptyPrintTicket,
       gfx::Size(100, 100), print_data,
       base::Bind(&RecordPrintResult, &call_count, &success, &status));
 
   EXPECT_EQ(1u, call_count);
 
   EXPECT_FALSE(success);
   EXPECT_EQ("INVALID_DATA", status);
 }