extensions/browser/api/printer_provider/printer_provider_apitest.cc

   1 // Copyright 2015 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 "base/bind.h"
   6 #include "base/files/file.h"
   7 #include "base/files/file_path.h"
   8 #include "base/files/file_util.h"
   9 #include "base/files/scoped_temp_dir.h"
  10 #include "base/json/json_string_value_serializer.h"
  11 #include "base/memory/ref_counted_memory.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/run_loop.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "extensions/browser/api/printer_provider/printer_provider_api.h"
  17 #include "extensions/browser/api/printer_provider/printer_provider_api_factory.h"
  18 #include "extensions/browser/api/printer_provider/printer_provider_print_job.h"
  19 #include "extensions/browser/extension_registry.h"
  20 #include "extensions/common/extension.h"
  21 #include "extensions/common/value_builder.h"
  22 #include "extensions/shell/test/shell_apitest.h"
  23 #include "extensions/test/extension_test_message_listener.h"
  24 #include "extensions/test/result_catcher.h"
  25 #include "testing/gtest/include/gtest/gtest.h"
  26
  27 namespace extensions {
  28
  29 namespace {
  30
  31 // Callback for PrinterProviderAPI::DispatchGetPrintersRequested calls.
  32 // It appends items in |printers| to |*printers_out|. If |done| is set, it runs
  33 // |callback|.
  34 void AppendPrintersAndRunCallbackIfDone(base::ListValue* printers_out,
  35                                         const base::Closure& callback,
  36                                         const base::ListValue& printers,
  37                                         bool done) {
  38   for (size_t i = 0; i < printers.GetSize(); ++i) {
  39     const base::DictionaryValue* printer = NULL;
  40     EXPECT_TRUE(printers.GetDictionary(i, &printer))
  41         << "Found invalid printer value at index " << i << ": " << printers;
  42     if (printer)
  43       printers_out->Append(printer->DeepCopy());
  44   }
  45   if (done && !callback.is_null())
  46     callback.Run();
  47 }
  48
  49 // Callback for PrinterProviderAPI::DispatchPrintRequested calls.
  50 // It copies |value| to |*result| and runs |callback|.
  51 void RecordPrintResultAndRunCallback(bool* result_success,
  52                                      std::string* result_status,
  53                                      const base::Closure& callback,
  54                                      bool success,
  55                                      const std::string& status) {
  56   *result_success = success;
  57   *result_status = status;
  58   if (!callback.is_null())
  59     callback.Run();
  60 }
  61
  62 // Callback for PrinterProviderAPI::DispatchGetCapabilityRequested calls.
  63 // It saves reported |value| as JSON string to |*result| and runs |callback|.
  64 void RecordDictAndRunCallback(std::string* result,
  65                               const base::Closure& callback,
  66                               const base::DictionaryValue& value) {
  67   JSONStringValueSerializer serializer(result);
  68   EXPECT_TRUE(serializer.Serialize(value));
  69   if (!callback.is_null())
  70     callback.Run();
  71 }
  72
  73 // Tests for chrome.printerProvider API.
  74 class PrinterProviderApiTest : public ShellApiTest {
  75  public:
  76   enum PrintRequestDataType {
  77     PRINT_REQUEST_DATA_TYPE_NOT_SET,
  78     PRINT_REQUEST_DATA_TYPE_FILE,
  79     PRINT_REQUEST_DATA_TYPE_FILE_DELETED,
  80     PRINT_REQUEST_DATA_TYPE_BYTES
  81   };
  82
  83   PrinterProviderApiTest() {}
  84   ~PrinterProviderApiTest() override {}
  85
  86   void StartGetPrintersRequest(
  87       const PrinterProviderAPI::GetPrintersCallback& callback) {
  88     PrinterProviderAPIFactory::GetInstance()
  89         ->GetForBrowserContext(browser_context())
  90         ->DispatchGetPrintersRequested(callback);
  91   }
  92
  93   void StartPrintRequestWithNoData(
  94       const std::string& extension_id,
  95       const PrinterProviderAPI::PrintCallback& callback) {
  96     PrinterProviderPrintJob job;
  97     job.printer_id = extension_id + ":printer_id";
  98     job.ticket_json = "{}";
  99     job.content_type = "application/pdf";
 100
 101     PrinterProviderAPIFactory::GetInstance()
 102         ->GetForBrowserContext(browser_context())
 103         ->DispatchPrintRequested(job, callback);
 104   }
 105
 106   void StartPrintRequestUsingDocumentBytes(
 107       const std::string& extension_id,
 108       const PrinterProviderAPI::PrintCallback& callback) {
 109     PrinterProviderPrintJob job;
 110     job.printer_id = extension_id + ":printer_id";
 111     job.job_title = base::ASCIIToUTF16("Print job");
 112     job.ticket_json = "{}";
 113     job.content_type = "application/pdf";
 114     const unsigned char kDocumentBytes[] = {'b', 'y', 't', 'e', 's'};
 115     job.document_bytes =
 116         new base::RefCountedBytes(kDocumentBytes, arraysize(kDocumentBytes));
 117
 118     PrinterProviderAPIFactory::GetInstance()
 119         ->GetForBrowserContext(browser_context())
 120         ->DispatchPrintRequested(job, callback);
 121   }
 122
 123   bool StartPrintRequestUsingFileInfo(
 124       const std::string& extension_id,
 125       const PrinterProviderAPI::PrintCallback& callback) {
 126     PrinterProviderPrintJob job;
 127
 128     const char kBytes[] = {'b', 'y', 't', 'e', 's'};
 129     if (!CreateTempFileWithContents(kBytes, static_cast<int>(arraysize(kBytes)),
 130                                     &job.document_path, &job.file_info)) {
 131       ADD_FAILURE() << "Failed to create test file.";
 132       return false;
 133     }
 134
 135     job.printer_id = extension_id + ":printer_id";
 136     job.job_title = base::ASCIIToUTF16("Print job");
 137     job.ticket_json = "{}";
 138     job.content_type = "image/pwg-raster";
 139
 140     PrinterProviderAPIFactory::GetInstance()
 141         ->GetForBrowserContext(browser_context())
 142         ->DispatchPrintRequested(job, callback);
 143     return true;
 144   }
 145
 146   void StartCapabilityRequest(
 147       const std::string& extension_id,
 148       const PrinterProviderAPI::GetCapabilityCallback& callback) {
 149     PrinterProviderAPIFactory::GetInstance()
 150         ->GetForBrowserContext(browser_context())
 151         ->DispatchGetCapabilityRequested(extension_id + ":printer_id",
 152                                          callback);
 153   }
 154
 155   // Loads chrome.printerProvider test app and initializes is for test
 156   // |test_param|.
 157   // When the app's background page is loaded, the app will send 'loaded'
 158   // message. As a response to the message it will expect string message
 159   // specifying the test that should be run. When the app initializes its state
 160   // (e.g. registers listener for a chrome.printerProvider event) it will send
 161   // message 'ready', at which point the test may be started.
 162   // If the app is successfully initialized, |*extension_id_out| will be set to
 163   // the loaded extension's id, otherwise it will remain unchanged.
 164   void InitializePrinterProviderTestApp(const std::string& app_path,
 165                                         const std::string& test_param,
 166                                         std::string* extension_id_out) {
 167     ExtensionTestMessageListener loaded_listener("loaded", true);
 168     ExtensionTestMessageListener ready_listener("ready", false);
 169
 170     const Extension* extension = LoadApp(app_path);
 171     ASSERT_TRUE(extension);
 172     const std::string extension_id = extension->id();
 173
 174     loaded_listener.set_extension_id(extension_id);
 175     ready_listener.set_extension_id(extension_id);
 176
 177     ASSERT_TRUE(loaded_listener.WaitUntilSatisfied());
 178
 179     loaded_listener.Reply(test_param);
 180
 181     ASSERT_TRUE(ready_listener.WaitUntilSatisfied());
 182
 183     *extension_id_out = extension_id;
 184   }
 185
 186   // Runs a test for chrome.printerProvider.onPrintRequested event.
 187   // |test_param|: The test that should be run.
 188   // |expected_result|: The print result the app is expected to report.
 189   void RunPrintRequestTestApp(const std::string& test_param,
 190                               PrintRequestDataType data_type,
 191                               const std::string& expected_result) {
 192     ResultCatcher catcher;
 193
 194     std::string extension_id;
 195     InitializePrinterProviderTestApp("api_test/printer_provider/request_print",
 196                                      test_param, &extension_id);
 197     if (extension_id.empty())
 198       return;
 199
 200     base::RunLoop run_loop;
 201     bool success;
 202     std::string print_status;
 203     PrinterProviderAPI::PrintCallback callback =
 204         base::Bind(&RecordPrintResultAndRunCallback, &success, &print_status,
 205                    run_loop.QuitClosure());
 206
 207     switch (data_type) {
 208       case PRINT_REQUEST_DATA_TYPE_NOT_SET:
 209         StartPrintRequestWithNoData(extension_id, callback);
 210         break;
 211       case PRINT_REQUEST_DATA_TYPE_FILE:
 212         ASSERT_TRUE(StartPrintRequestUsingFileInfo(extension_id, callback));
 213         break;
 214       case PRINT_REQUEST_DATA_TYPE_FILE_DELETED:
 215         ASSERT_TRUE(StartPrintRequestUsingFileInfo(extension_id, callback));
 216         ASSERT_TRUE(data_dir_.Delete());
 217         break;
 218       case PRINT_REQUEST_DATA_TYPE_BYTES:
 219         StartPrintRequestUsingDocumentBytes(extension_id, callback);
 220         break;
 221     }
 222
 223     if (data_type != PRINT_REQUEST_DATA_TYPE_NOT_SET)
 224       ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 225
 226     run_loop.Run();
 227     EXPECT_EQ(expected_result, print_status);
 228     EXPECT_EQ(expected_result == "OK", success);
 229   }
 230
 231   // Runs a test for chrome.printerProvider.onGetCapabilityRequested
 232   // event.
 233   // |test_param|: The test that should be run.
 234   // |expected_result|: The printer capability the app is expected to report.
 235   void RunPrinterCapabilitiesRequestTest(const std::string& test_param,
 236                                          const std::string& expected_result) {
 237     ResultCatcher catcher;
 238
 239     std::string extension_id;
 240     InitializePrinterProviderTestApp(
 241         "api_test/printer_provider/request_capability", test_param,
 242         &extension_id);
 243     if (extension_id.empty())
 244       return;
 245
 246     base::RunLoop run_loop;
 247     std::string result;
 248     StartCapabilityRequest(
 249         extension_id,
 250         base::Bind(&RecordDictAndRunCallback, &result, run_loop.QuitClosure()));
 251
 252     ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 253
 254     run_loop.Run();
 255     EXPECT_EQ(expected_result, result);
 256   }
 257
 258   bool SimulateExtensionUnload(const std::string& extension_id) {
 259     ExtensionRegistry* extension_registry =
 260         ExtensionRegistry::Get(browser_context());
 261
 262     const Extension* extension = extension_registry->GetExtensionById(
 263         extension_id, ExtensionRegistry::ENABLED);
 264     if (!extension)
 265       return false;
 266
 267     extension_registry->RemoveEnabled(extension_id);
 268     extension_registry->TriggerOnUnloaded(
 269         extension, UnloadedExtensionInfo::REASON_TERMINATE);
 270     return true;
 271   }
 272
 273   // Validates that set of printers reported by test apps via
 274   // chrome.printerProvider.onGetPritersRequested is the same as the set of
 275   // printers in |expected_printers|. |expected_printers| contains list of
 276   // printer objects formatted as a JSON string. It is assumed that the values
 277   // in |expoected_printers| are unique.
 278   void ValidatePrinterListValue(
 279       const base::ListValue& printers,
 280       const ScopedVector<base::Value>& expected_printers) {
 281     ASSERT_EQ(expected_printers.size(), printers.GetSize());
 282     for (const base::Value* printer_value : expected_printers) {
 283       EXPECT_TRUE(printers.Find(*printer_value) != printers.end())
 284           << "Unabe to find " << *printer_value << " in " << printers;
 285     }
 286   }
 287
 288  private:
 289   // Initializes |data_dir_| if needed and creates a file in it containing
 290   // provided data.
 291   bool CreateTempFileWithContents(const char* data,
 292                                   int size,
 293                                   base::FilePath* path,
 294                                   base::File::Info* file_info) {
 295     if (!data_dir_.IsValid() && !data_dir_.CreateUniqueTempDir())
 296       return false;
 297
 298     *path = data_dir_.path().AppendASCII("data.pwg");
 299     int written = base::WriteFile(*path, data, size);
 300     if (written != size)
 301       return false;
 302     if (!base::GetFileInfo(*path, file_info))
 303       return false;
 304     return true;
 305   }
 306
 307   base::ScopedTempDir data_dir_;
 308
 309   DISALLOW_COPY_AND_ASSIGN(PrinterProviderApiTest);
 310 };
 311
 312 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobSuccess) {
 313   RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_BYTES, "OK");
 314 }
 315
 316 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobWithFileSuccess) {
 317   RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_FILE, "OK");
 318 }
 319
 320 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 321                        PrintJobWithFile_FileDeletedBeforeDispatch) {
 322   RunPrintRequestTestApp("OK", PRINT_REQUEST_DATA_TYPE_FILE_DELETED,
 323                          "INVALID_DATA");
 324 }
 325
 326 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobAsyncSuccess) {
 327   RunPrintRequestTestApp("ASYNC_RESPONSE", PRINT_REQUEST_DATA_TYPE_BYTES, "OK");
 328 }
 329
 330 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintJobFailed) {
 331   RunPrintRequestTestApp("INVALID_TICKET", PRINT_REQUEST_DATA_TYPE_BYTES,
 332                          "INVALID_TICKET");
 333 }
 334
 335 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, NoPrintEventListener) {
 336   RunPrintRequestTestApp("NO_LISTENER", PRINT_REQUEST_DATA_TYPE_BYTES,
 337                          "FAILED");
 338 }
 339
 340 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 341                        PrintRequestInvalidCallbackParam) {
 342   RunPrintRequestTestApp("INVALID_VALUE", PRINT_REQUEST_DATA_TYPE_BYTES,
 343                          "FAILED");
 344 }
 345
 346 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintRequestDataNotSet) {
 347   RunPrintRequestTestApp("IGNORE_CALLBACK", PRINT_REQUEST_DATA_TYPE_NOT_SET,
 348                          "FAILED");
 349 }
 350
 351 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, PrintRequestAppUnloaded) {
 352   ResultCatcher catcher;
 353
 354   std::string extension_id;
 355   InitializePrinterProviderTestApp("api_test/printer_provider/request_print",
 356                                    "IGNORE_CALLBACK", &extension_id);
 357   ASSERT_FALSE(extension_id.empty());
 358
 359   base::RunLoop run_loop;
 360   bool success = false;
 361   std::string status;
 362   StartPrintRequestUsingDocumentBytes(
 363       extension_id, base::Bind(&RecordPrintResultAndRunCallback, &success,
 364                                &status, run_loop.QuitClosure()));
 365
 366   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 367
 368   ASSERT_TRUE(SimulateExtensionUnload(extension_id));
 369
 370   run_loop.Run();
 371   EXPECT_FALSE(success);
 372   EXPECT_EQ("FAILED", status);
 373 }
 374
 375 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetCapabilitySuccess) {
 376   RunPrinterCapabilitiesRequestTest("OK", "{\"capability\":\"value\"}");
 377 }
 378
 379 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetCapabilityAsyncSuccess) {
 380   RunPrinterCapabilitiesRequestTest("ASYNC_RESPONSE",
 381                                     "{\"capability\":\"value\"}");
 382 }
 383
 384 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, EmptyCapability) {
 385   RunPrinterCapabilitiesRequestTest("EMPTY", "{}");
 386 }
 387
 388 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, NoCapabilityEventListener) {
 389   RunPrinterCapabilitiesRequestTest("NO_LISTENER", "{}");
 390 }
 391
 392 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, CapabilityInvalidValue) {
 393   RunPrinterCapabilitiesRequestTest("INVALID_VALUE", "{}");
 394 }
 395
 396 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetCapabilityAppUnloaded) {
 397   ResultCatcher catcher;
 398
 399   std::string extension_id;
 400   InitializePrinterProviderTestApp(
 401       "api_test/printer_provider/request_capability", "IGNORE_CALLBACK",
 402       &extension_id);
 403   ASSERT_FALSE(extension_id.empty());
 404
 405   base::RunLoop run_loop;
 406   std::string result;
 407   StartCapabilityRequest(
 408       extension_id,
 409       base::Bind(&RecordDictAndRunCallback, &result, run_loop.QuitClosure()));
 410
 411   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 412
 413   ASSERT_TRUE(SimulateExtensionUnload(extension_id));
 414   run_loop.Run();
 415   EXPECT_EQ("{}", result);
 416 }
 417
 418 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersSuccess) {
 419   ResultCatcher catcher;
 420
 421   std::string extension_id;
 422   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 423                                    "OK", &extension_id);
 424   ASSERT_FALSE(extension_id.empty());
 425
 426   base::RunLoop run_loop;
 427   base::ListValue printers;
 428
 429   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 430                                      &printers, run_loop.QuitClosure()));
 431
 432   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 433
 434   run_loop.Run();
 435
 436   ScopedVector<base::Value> expected_printers;
 437   expected_printers.push_back(
 438       DictionaryBuilder()
 439           .Set("description", "Test printer")
 440           .Set("extensionId", extension_id)
 441           .Set("extensionName", "Test printer provider")
 442           .Set("id", base::StringPrintf("%s:printer1", extension_id.c_str()))
 443           .Set("name", "Printer 1")
 444           .Build());
 445   expected_printers.push_back(
 446       DictionaryBuilder()
 447           .Set("extensionId", extension_id)
 448           .Set("extensionName", "Test printer provider")
 449           .Set("id",
 450                base::StringPrintf("%s:printerNoDesc", extension_id.c_str()))
 451           .Set("name", "Printer 2")
 452           .Build());
 453
 454   ValidatePrinterListValue(printers, expected_printers);
 455 }
 456
 457 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersAsyncSuccess) {
 458   ResultCatcher catcher;
 459
 460   std::string extension_id;
 461   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 462                                    "ASYNC_RESPONSE", &extension_id);
 463   ASSERT_FALSE(extension_id.empty());
 464
 465   base::RunLoop run_loop;
 466   base::ListValue printers;
 467
 468   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 469                                      &printers, run_loop.QuitClosure()));
 470
 471   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 472
 473   run_loop.Run();
 474
 475   ScopedVector<base::Value> expected_printers;
 476   expected_printers.push_back(
 477       DictionaryBuilder()
 478           .Set("description", "Test printer")
 479           .Set("extensionId", extension_id)
 480           .Set("extensionName", "Test printer provider")
 481           .Set("id", base::StringPrintf("%s:printer1", extension_id.c_str()))
 482           .Set("name", "Printer 1")
 483           .Build());
 484
 485   ValidatePrinterListValue(printers, expected_printers);
 486 }
 487
 488 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersTwoExtensions) {
 489   ResultCatcher catcher;
 490
 491   std::string extension_id_1;
 492   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 493                                    "OK", &extension_id_1);
 494   ASSERT_FALSE(extension_id_1.empty());
 495
 496   std::string extension_id_2;
 497   InitializePrinterProviderTestApp(
 498       "api_test/printer_provider/request_printers_second", "OK",
 499       &extension_id_2);
 500   ASSERT_FALSE(extension_id_2.empty());
 501
 502   base::RunLoop run_loop;
 503   base::ListValue printers;
 504
 505   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 506                                      &printers, run_loop.QuitClosure()));
 507
 508   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 509   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 510
 511   run_loop.Run();
 512
 513   ScopedVector<base::Value> expected_printers;
 514   expected_printers.push_back(
 515       DictionaryBuilder()
 516           .Set("description", "Test printer")
 517           .Set("extensionId", extension_id_1)
 518           .Set("extensionName", "Test printer provider")
 519           .Set("id", base::StringPrintf("%s:printer1", extension_id_1.c_str()))
 520           .Set("name", "Printer 1")
 521           .Build());
 522   expected_printers.push_back(
 523       DictionaryBuilder()
 524           .Set("extensionId", extension_id_1)
 525           .Set("extensionName", "Test printer provider")
 526           .Set("id",
 527                base::StringPrintf("%s:printerNoDesc", extension_id_1.c_str()))
 528           .Set("name", "Printer 2")
 529           .Build());
 530   expected_printers.push_back(
 531       DictionaryBuilder()
 532           .Set("description", "Test printer")
 533           .Set("extensionId", extension_id_2)
 534           .Set("extensionName", "Test printer provider")
 535           .Set("id", base::StringPrintf("%s:printer1", extension_id_2.c_str()))
 536           .Set("name", "Printer 1")
 537           .Build());
 538   expected_printers.push_back(
 539       DictionaryBuilder()
 540           .Set("extensionId", extension_id_2)
 541           .Set("extensionName", "Test printer provider")
 542           .Set("id",
 543                base::StringPrintf("%s:printerNoDesc", extension_id_2.c_str()))
 544           .Set("name", "Printer 2")
 545           .Build());
 546
 547   ValidatePrinterListValue(printers, expected_printers);
 548 }
 549
 550 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 551                        GetPrintersTwoExtensionsBothUnloaded) {
 552   ResultCatcher catcher;
 553
 554   std::string extension_id_1;
 555   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 556                                    "IGNORE_CALLBACK", &extension_id_1);
 557   ASSERT_FALSE(extension_id_1.empty());
 558
 559   std::string extension_id_2;
 560   InitializePrinterProviderTestApp(
 561       "api_test/printer_provider/request_printers_second", "IGNORE_CALLBACK",
 562       &extension_id_2);
 563   ASSERT_FALSE(extension_id_2.empty());
 564
 565   base::RunLoop run_loop;
 566   base::ListValue printers;
 567
 568   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 569                                      &printers, run_loop.QuitClosure()));
 570
 571   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 572   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 573
 574   ASSERT_TRUE(SimulateExtensionUnload(extension_id_1));
 575   ASSERT_TRUE(SimulateExtensionUnload(extension_id_2));
 576
 577   run_loop.Run();
 578
 579   EXPECT_TRUE(printers.empty());
 580 }
 581
 582 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 583                        GetPrintersTwoExtensionsOneFails) {
 584   ResultCatcher catcher;
 585
 586   std::string extension_id_1;
 587   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 588                                    "NOT_ARRAY", &extension_id_1);
 589   ASSERT_FALSE(extension_id_1.empty());
 590
 591   std::string extension_id_2;
 592   InitializePrinterProviderTestApp(
 593       "api_test/printer_provider/request_printers_second", "OK",
 594       &extension_id_2);
 595   ASSERT_FALSE(extension_id_2.empty());
 596
 597   base::RunLoop run_loop;
 598   base::ListValue printers;
 599
 600   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 601                                      &printers, run_loop.QuitClosure()));
 602
 603   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 604   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 605
 606   run_loop.Run();
 607
 608   ScopedVector<base::Value> expected_printers;
 609   expected_printers.push_back(
 610       DictionaryBuilder()
 611           .Set("description", "Test printer")
 612           .Set("extensionId", extension_id_2)
 613           .Set("extensionName", "Test printer provider")
 614           .Set("id", base::StringPrintf("%s:printer1", extension_id_2.c_str()))
 615           .Set("name", "Printer 1")
 616           .Build());
 617   expected_printers.push_back(
 618       DictionaryBuilder()
 619           .Set("extensionId", extension_id_2)
 620           .Set("extensionName", "Test printer provider")
 621           .Set("id",
 622                base::StringPrintf("%s:printerNoDesc", extension_id_2.c_str()))
 623           .Set("name", "Printer 2")
 624           .Build());
 625
 626   ValidatePrinterListValue(printers, expected_printers);
 627 }
 628
 629 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 630                        GetPrintersTwoExtensionsOneWithNoListener) {
 631   ResultCatcher catcher;
 632
 633   std::string extension_id_1;
 634   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 635                                    "NO_LISTENER", &extension_id_1);
 636   ASSERT_FALSE(extension_id_1.empty());
 637
 638   std::string extension_id_2;
 639   InitializePrinterProviderTestApp(
 640       "api_test/printer_provider/request_printers_second", "OK",
 641       &extension_id_2);
 642   ASSERT_FALSE(extension_id_2.empty());
 643
 644   base::RunLoop run_loop;
 645   base::ListValue printers;
 646
 647   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 648                                      &printers, run_loop.QuitClosure()));
 649
 650   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 651   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 652
 653   run_loop.Run();
 654
 655   ScopedVector<base::Value> expected_printers;
 656   expected_printers.push_back(
 657       DictionaryBuilder()
 658           .Set("description", "Test printer")
 659           .Set("extensionId", extension_id_2)
 660           .Set("extensionName", "Test printer provider")
 661           .Set("id", base::StringPrintf("%s:printer1", extension_id_2.c_str()))
 662           .Set("name", "Printer 1")
 663           .Build());
 664   expected_printers.push_back(
 665       DictionaryBuilder()
 666           .Set("extensionId", extension_id_2)
 667           .Set("extensionName", "Test printer provider")
 668           .Set("id",
 669                base::StringPrintf("%s:printerNoDesc", extension_id_2.c_str()))
 670           .Set("name", "Printer 2")
 671           .Build());
 672
 673   ValidatePrinterListValue(printers, expected_printers);
 674 }
 675
 676 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersNoListener) {
 677   ResultCatcher catcher;
 678
 679   std::string extension_id;
 680   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 681                                    "NO_LISTENER", &extension_id);
 682   ASSERT_FALSE(extension_id.empty());
 683
 684   base::RunLoop run_loop;
 685   base::ListValue printers;
 686
 687   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 688                                      &printers, run_loop.QuitClosure()));
 689
 690   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 691
 692   run_loop.Run();
 693
 694   EXPECT_TRUE(printers.empty());
 695 }
 696
 697 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersNotArray) {
 698   ResultCatcher catcher;
 699
 700   std::string extension_id;
 701   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 702                                    "NOT_ARRAY", &extension_id);
 703   ASSERT_FALSE(extension_id.empty());
 704
 705   base::RunLoop run_loop;
 706   base::ListValue printers;
 707
 708   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 709                                      &printers, run_loop.QuitClosure()));
 710
 711   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 712
 713   run_loop.Run();
 714
 715   EXPECT_TRUE(printers.empty());
 716 }
 717
 718 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest,
 719                        GetPrintersInvalidPrinterValueType) {
 720   ResultCatcher catcher;
 721
 722   std::string extension_id;
 723   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 724                                    "INVALID_PRINTER_TYPE", &extension_id);
 725   ASSERT_FALSE(extension_id.empty());
 726
 727   base::RunLoop run_loop;
 728   base::ListValue printers;
 729
 730   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 731                                      &printers, run_loop.QuitClosure()));
 732
 733   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 734
 735   run_loop.Run();
 736
 737   EXPECT_TRUE(printers.empty());
 738 }
 739
 740 IN_PROC_BROWSER_TEST_F(PrinterProviderApiTest, GetPrintersInvalidPrinterValue) {
 741   ResultCatcher catcher;
 742
 743   std::string extension_id;
 744   InitializePrinterProviderTestApp("api_test/printer_provider/request_printers",
 745                                    "INVALID_PRINTER", &extension_id);
 746   ASSERT_FALSE(extension_id.empty());
 747
 748   base::RunLoop run_loop;
 749   base::ListValue printers;
 750
 751   StartGetPrintersRequest(base::Bind(&AppendPrintersAndRunCallbackIfDone,
 752                                      &printers, run_loop.QuitClosure()));
 753
 754   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
 755
 756   run_loop.Run();
 757
 758   EXPECT_TRUE(printers.empty());
 759 }
 760
 761 }  // namespace
 762
 763 }  // namespace extensions