Instead of ArrayBuffer, pass blob with printerProvider.onPrintRequested

extensions/browser/api/printer_provider/printer_provider_apitest.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 "base/bind.h"
+#include "base/files/file.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/files/scoped_temp_dir.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/shell/test/shell_apitest.h"
@@ skipping 44 matching lines @@
                               const base::DictionaryValue& value) {
   JSONStringValueSerializer serializer(result);
   EXPECT_TRUE(serializer.Serialize(value));
   if (!callback.is_null())
     callback.Run();
 }
 
 // Tests for chrome.printerProvider API.
 class PrinterProviderApiTest : public extensions::ShellApiTest {
  public:
+  enum PrintRequestDataType {
+    PRINT_REQUEST_DATA_TYPE_NOT_SET,
+    PRINT_REQUEST_DATA_TYPE_FILE,
+    PRINT_REQUEST_DATA_TYPE_FILE_DELETED,
+    PRINT_REQUEST_DATA_TYPE_BYTES
+  };
+
   PrinterProviderApiTest() {}
   ~PrinterProviderApiTest() override {}
 
   void StartGetPrintersRequest(
       const PrinterProviderAPI::GetPrintersCallback& callback) {
     PrinterProviderAPIFactory::GetInstance()
         ->GetForBrowserContext(browser_context())
         ->DispatchGetPrintersRequested(callback);
   }
 
-  void StartPrintRequest(const std::string& extension_id,
-                         const PrinterProviderAPI::PrintCallback& callback) {
+  void StartPrintRequestWithNoData(
+      const std::string& extension_id,
+      const PrinterProviderAPI::PrintCallback& callback) {
     extensions::PrinterProviderPrintJob job;
     job.printer_id = extension_id + ":printer_id";
     job.ticket_json = "{}";
-    job.content_type = "content_type";
-    const unsigned char kDocumentBytes[] = {'b', 'y', 't', 'e', 's', 0};
+    job.content_type = "application/pdf";
+
+    PrinterProviderAPIFactory::GetInstance()
+        ->GetForBrowserContext(browser_context())
+        ->DispatchPrintRequested(job, callback);
+  }
+
+  void StartPrintRequestUsingDocumentBytes(
+      const std::string& extension_id,
+      const PrinterProviderAPI::PrintCallback& callback) {
+    extensions::PrinterProviderPrintJob job;
+    job.printer_id = extension_id + ":printer_id";
+    job.ticket_json = "{}";
+    job.content_type = "application/pdf";
+    const unsigned char kDocumentBytes[] = {'b', 'y', 't', 'e', 's'};
     job.document_bytes =
         new base::RefCountedBytes(kDocumentBytes, arraysize(kDocumentBytes));
 
     PrinterProviderAPIFactory::GetInstance()
         ->GetForBrowserContext(browser_context())
         ->DispatchPrintRequested(job, callback);
   }
 
+  bool StartPrintRequestUsingFileInfo(
+      const std::string& extension_id,
+      const PrinterProviderAPI::PrintCallback& callback) {
+    extensions::PrinterProviderPrintJob job;
+
+    const char kBytes[] = {'b', 'y', 't', 'e', 's'};
+    if (!CreateTempFileWithContents(kBytes, static_cast<int>(arraysize(kBytes)),
+                                    &job.document_path, &job.file_info)) {
+      ADD_FAILURE() << "Failed to create test file.";
+      return false;
+    }
+
+    job.printer_id = extension_id + ":printer_id";
+    job.ticket_json = "{}";
+    job.content_type = "image/pwg-raster";
+
+    PrinterProviderAPIFactory::GetInstance()
+        ->GetForBrowserContext(browser_context())
+        ->DispatchPrintRequested(job, callback);
+    return true;
+  }
+
   void StartCapabilityRequest(
       const std::string& extension_id,
       const PrinterProviderAPI::GetCapabilityCallback& callback) {
     PrinterProviderAPIFactory::GetInstance()
         ->GetForBrowserContext(browser_context())
         ->DispatchGetCapabilityRequested(extension_id + ":printer_id",
                                          callback);
   }
 
   // Loads chrome.printerProvider test app and initializes is for test
@@ skipping 24 matching lines @@
 
     ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 
     *extension_id_out = extension_id;
   }
 
   // Runs a test for chrome.printerProvider.onPrintRequested event.
   // |test_param|: The test that should be run.
   // |expected_result|: The print result the app is expected to report.
   void RunPrintRequestTestApp(const std::string& test_param,
+                              PrintRequestDataType data_type,
                               const std::string& expected_result) {
     extensions::ResultCatcher catcher;
 
     std::string extension_id;
     InitializePrinterProviderTestApp("api_test/printer_provider/request_print",
                                      test_param, &extension_id);
     if (extension_id.empty())
       return;
 
     base::RunLoop run_loop;
     bool success;
     std::string print_status;
-    StartPrintRequest(extension_id,
-                      base::Bind(&RecordPrintResultAndRunCallback, &success,
-                                 &print_status, run_loop.QuitClosure()));
+    PrinterProviderAPI::PrintCallback callback =
+        base::Bind(&RecordPrintResultAndRunCallback, &success, &print_status,
+                   run_loop.QuitClosure());
 
-    ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
+    switch (data_type) {
+      case PRINT_REQUEST_DATA_TYPE_NOT_SET:
+        StartPrintRequestWithNoData(extension_id, callback);
+        break;
+      case PRINT_REQUEST_DATA_TYPE_FILE:
+        ASSERT_TRUE(StartPrintRequestUsingFileInfo(extension_id, callback));
+        break;
+      case PRINT_REQUEST_DATA_TYPE_FILE_DELETED:
+        ASSERT_TRUE(StartPrintRequestUsingFileInfo(extension_id, callback));
+        ASSERT_TRUE(data_dir_.Delete());
+        break;
+      case PRINT_REQUEST_DATA_TYPE_BYTES:
+        StartPrintRequestUsingDocumentBytes(extension_id, callback);
+        break;
+    }
+
+    if (data_type != PRINT_REQUEST_DATA_TYPE_NOT_SET)
+      ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
     run_loop.Run();
     EXPECT_EQ(expected_result, print_status);
     EXPECT_EQ(expected_result == "OK", success);
   }
 
   // Runs a test for chrome.printerProvider.onGetCapabilityRequested
   // event.
   // |test_param|: The test that should be run.
   // |expected_result|: The printer capability the app is expected to report.
@@ skipping 52 matching lines @@
           deserializer.Deserialize(&error_code, NULL));
       ASSERT_TRUE(printer_value) << "Failed to deserialize "
                                  << expected_printers[i] << ": "
                                  << "error code " << error_code;
       EXPECT_TRUE(printers.Find(*printer_value) != printers.end())
           << "Unabe to find " << *printer_value << " in " << printers;
     }
   }
 
  private:
+  // Initializes |data_dir_| if needed and creates a file in it containing
+  // provided data.
+  bool CreateTempFileWithContents(const char* data,
+                                  int size,
+                                  base::FilePath* path,
+                                  base::File::Info* file_info) {
+    if (!data_dir_.IsValid() && !data_dir_.CreateUniqueTempDir())
+      return false;
+
+    *path = data_dir_.path().AppendASCII("data.pwg");
+    int written = base::WriteFile(*path, data, size);
+    if (written != size)
+      return false;
+    if (!base::GetFileInfo(*path, file_info))
+      return false;
+    return true;
+  }
+
+  base::ScopedTempDir data_dir_;
+
   DISALLOW_COPY_AND_ASSIGN(PrinterProviderApiTest);
 };
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobSuccess) {
-  RunPrintRequestTestApp("OK", "OK");
+  RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_BYTES, "OK");
+}
+
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobWithFileSuccess) {
+  RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_FILE, "OK");
+}
+
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
+                       PrintJobWithFile_FileDeletedBeforeDispatch) {
+  RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_FILE_DELETED,
+                         "INVALID_DATA");
 }
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobAsyncSuccess) {
-  RunPrintRequestTestApp("ASYNC_RESPONSE", "OK");
+  RunPrintRequestTestApp("ASYNC_RESPONSE", PRINT_REQUEST_DATA_TYPE_BYTES, "OK");
 }
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobFailed) {
-  RunPrintRequestTestApp("INVALID_TICKET", "INVALID_TICKET");
+  RunPrintRequestTestApp("INVALID_TICKET", PRINT_REQUEST_DATA_TYPE_BYTES,
+                         "INVALID_TICKET");
 }
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, NoPrintEventListener) {
-  RunPrintRequestTestApp("NO_LISTENER", "FAILED");
+  RunPrintRequestTestApp("NO_LISTENER", PRINT_REQUEST_DATA_TYPE_BYTES,
+                         "FAILED");
 }
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
                        PrintRequestInvalidCallbackParam) {
-  RunPrintRequestTestApp("INVALID_VALUE", "FAILED");
+  RunPrintRequestTestApp("INVALID_VALUE", PRINT_REQUEST_DATA_TYPE_BYTES,
+                         "FAILED");
+}
+
+IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintRequestDataNotSet) {
+  RunPrintRequestTestApp("IGNORE_CALLBACK", PRINT_REQUEST_DATA_TYPE_NOT_SET,
+                         "FAILED");
 }
 
 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintRequestAppUnloaded) {
   extensions::ResultCatcher catcher;
 
   std::string extension_id;
   InitializePrinterProviderTestApp("api_test/printer_provider/request_print",
                                    "IGNORE_CALLBACK", &extension_id);
   ASSERT_FALSE(extension_id.empty());
 
   base::RunLoop run_loop;
   bool success = false;
   std::string status;
-  StartPrintRequest(extension_id,
-                    base::Bind(&RecordPrintResultAndRunCallback, &success,
+  StartPrintRequestUsingDocumentBytes(
+      extension_id, base::Bind(&RecordPrintResultAndRunCallback, &success,
                                &status, run_loop.QuitClosure()));
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   ASSERT_TRUE(SimulateExtensionUnload(extension_id));
 
   run_loop.Run();
   EXPECT_FALSE(success);
   EXPECT_EQ("FAILED", status);
 }
@@ skipping 373 matching lines @@
                                      &printers, run_loop.QuitClosure()));
 
   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 
   run_loop.Run();
 
   EXPECT_TRUE(printers.empty());
 }
 
 }  // namespace