Unpack theme data from extensions off of UI thread.

chrome/browser/themes/browser_theme_pack_unittest.cc

 // Copyright (c) 2012 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/themes/browser_theme_pack.h"
 
 #include <stddef.h>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
+#include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/grit/theme_resources.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/image/image_skia_rep.h"
 
 using extensions::Extension;
 
 // Maps scale factors (enum values) to file path.
 // A similar typedef in BrowserThemePack is private.
 typedef std::map<ui::ScaleFactor, base::FilePath> TestScaleFactorToFileMap;
 
 // Maps image ids to maps of scale factors to file paths.
 // A similar typedef in BrowserThemePack is private.
 typedef std::map<int, TestScaleFactorToFileMap> TestFilePathMap;
 
 class BrowserThemePackTest : public ::testing::Test {
  public:
-  BrowserThemePackTest() {
+  BrowserThemePackTest()
+      : thread_bundle_(content::TestBrowserThreadBundle::REAL_IO_THREAD),
+        theme_pack_(new BrowserThemePack()) {
     std::vector<ui::ScaleFactor> scale_factors;
     scale_factors.push_back(ui::SCALE_FACTOR_100P);
     scale_factors.push_back(ui::SCALE_FACTOR_200P);
     scoped_set_supported_scale_factors_.reset(
-      new ui::test::ScopedSetSupportedScaleFactors(scale_factors));
-    theme_pack_ = new BrowserThemePack();
+        new ui::test::ScopedSetSupportedScaleFactors(scale_factors));
   }
+  ~BrowserThemePackTest() override {}
 
   // Transformation for link underline colors.
   SkColor BuildThirdOpacity(SkColor color_link) {
     return SkColorSetA(color_link, SkColorGetA(color_link) / 3);
   }
 
   void GenerateDefaultFrameColor(std::map<int, SkColor>* colors,
                                  int color, int tint, bool otr) {
     (*colors)[color] = HSLShift(
         ThemeProperties::GetDefaultColor(ThemeProperties::COLOR_FRAME, false),
@@ skipping 80 matching lines @@
       base::DictionaryValue* value,
       TestFilePathMap* out_file_paths) {
     theme_pack_->ParseImageNamesFromJSON(value, base::FilePath(),
                                          out_file_paths);
 
     // Build the source image list for HasCustomImage().
     theme_pack_->BuildSourceImagesArray(*out_file_paths);
   }
 
   bool LoadRawBitmapsTo(const TestFilePathMap& out_file_paths) {
-    return theme_pack_->LoadRawBitmapsTo(out_file_paths,
-                                         &theme_pack_->images_on_ui_thread_);
+    return theme_pack_->LoadRawBitmapsTo(out_file_paths, &theme_pack_->images_);
   }
 
   // This function returns void in order to be able use ASSERT_...
   // The BrowserThemePack is returned in |pack|.
   void BuildFromUnpackedExtension(const base::FilePath& extension_path,
-                                  scoped_refptr<BrowserThemePack>& pack) {
-    base::FilePath manifest_path =
-        extension_path.AppendASCII("manifest.json");
-    std::string error;
-    JSONFileValueDeserializer deserializer(manifest_path);
-    std::unique_ptr<base::DictionaryValue> valid_value =
-        base::DictionaryValue::From(deserializer.Deserialize(NULL, &error));
-    EXPECT_EQ("", error);
-    ASSERT_TRUE(valid_value.get());
-    scoped_refptr<Extension> extension(
-        Extension::Create(
-            extension_path,
-            extensions::Manifest::INVALID_LOCATION,
-            *valid_value,
-            Extension::REQUIRE_KEY,
-            &error));
-    ASSERT_TRUE(extension.get());
-    ASSERT_EQ("", error);
-    pack = BrowserThemePack::BuildFromExtension(extension.get());
-    ASSERT_TRUE(pack.get());
+                                  scoped_refptr<BrowserThemePack>* pack) {
+    io_waiter_.reset(new base::WaitableEvent(
+        base::WaitableEvent::ResetPolicy::AUTOMATIC,
+        base::WaitableEvent::InitialState::NOT_SIGNALED));
+    content::BrowserThread::PostTask(
+        content::BrowserThread::IO, FROM_HERE,
+        base::Bind(&BrowserThemePackTest::DoBuildFromUnpackedExtension,
+                   base::Unretained(this), extension_path, pack));
+    io_waiter_->Wait();
+    ASSERT_TRUE((*pack)->is_valid());
   }
 
   base::FilePath GetStarGazingPath() {
     base::FilePath test_path;
     if (!PathService::Get(chrome::DIR_TEST_DATA, &test_path)) {
       NOTREACHED();
       return test_path;
     }
 
     test_path = test_path.AppendASCII("profiles");
@@ skipping 158 matching lines @@
     EXPECT_EQ(160, rep4.sk_bitmap().height());
     // We expect the same colors and at locations scaled by 2
     // since this bitmap was scaled by 2.
     for (size_t i = 0; i < normal.size(); ++i) {
       int xy = 2 * normal[i].first;
       SkColor color = normal[i].second;
       EXPECT_EQ(color, rep4.sk_bitmap().getColor(xy, xy));
     }
   }
 
-  content::TestBrowserThreadBundle test_browser_thread_bundle_;
-
+ protected:
   typedef std::unique_ptr<ui::test::ScopedSetSupportedScaleFactors>
       ScopedSetSupportedScaleFactors;
   ScopedSetSupportedScaleFactors scoped_set_supported_scale_factors_;
+
+  void DoBuildFromUnpackedExtension(const base::FilePath& extension_path,
+                                    scoped_refptr<BrowserThemePack>* pack) {
+    base::FilePath manifest_path = extension_path.AppendASCII("manifest.json");
+    std::string error;
+    JSONFileValueDeserializer deserializer(manifest_path);
+    std::unique_ptr<base::DictionaryValue> valid_value =
+        base::DictionaryValue::From(deserializer.Deserialize(NULL, &error));
+    EXPECT_EQ("", error);
+    ASSERT_TRUE(valid_value.get());
+    scoped_refptr<Extension> extension(Extension::Create(
+        extension_path, extensions::Manifest::INVALID_LOCATION, *valid_value,
+        Extension::REQUIRE_KEY, &error));
+    ASSERT_TRUE(extension.get());
+    ASSERT_EQ("", error);
+    *pack = new BrowserThemePack;
+    BrowserThemePack::BuildFromExtension(extension.get(), *pack);
+    io_waiter_->Signal();
+  }
+
+  content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<BrowserThemePack> theme_pack_;
+  std::unique_ptr<base::WaitableEvent> io_waiter_;
 };
 
 // 'ntp_section' used to correspond to ThemeProperties::COLOR_NTP_SECTION,
 // but COLOR_NTP_SECTION was since removed because it was never used.
 // While it was in use, COLOR_NTP_HEADER used 'ntp_section' as a fallback when
 // 'ntp_header' was absent.  We still preserve this fallback for themes that
 // relied on this.
 TEST_F(BrowserThemePackTest, UseSectionColorAsNTPHeader) {
   std::string color_json = "{ \"ntp_section\": [190, 190, 190] }";
   LoadColorJSON(color_json);
@@ skipping 196 matching lines @@
 // tricky memory stuff that BrowserThemePack does.
 TEST_F(BrowserThemePackTest, CanBuildAndReadPack) {
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath file = dir.GetPath().AppendASCII("data.pak");
 
   // Part 1: Build the pack from an extension.
   {
     base::FilePath star_gazing_path = GetStarGazingPath();
     scoped_refptr<BrowserThemePack> pack;
-    BuildFromUnpackedExtension(star_gazing_path, pack);
+    BuildFromUnpackedExtension(star_gazing_path, &pack);
     ASSERT_TRUE(pack->WriteToDisk(file));
     VerifyStarGazing(pack.get());
   }
 
   // Part 2: Try to read back the data pack that we just wrote to disk.
   {
     scoped_refptr<BrowserThemePack> pack =
         BrowserThemePack::BuildFromDataPack(
             file, "mblmlcbknbnfebdfjnolmcapmdofhmme");
     ASSERT_TRUE(pack.get());
     VerifyStarGazing(pack.get());
   }
 }
 
 TEST_F(BrowserThemePackTest, HiDpiThemeTest) {
   base::ScopedTempDir dir;
   ASSERT_TRUE(dir.CreateUniqueTempDir());
   base::FilePath file = dir.GetPath().AppendASCII("theme_data.pak");
 
   // Part 1: Build the pack from an extension.
   {
     base::FilePath hidpi_path = GetHiDpiThemePath();
     scoped_refptr<BrowserThemePack> pack;
-    BuildFromUnpackedExtension(hidpi_path, pack);
+    BuildFromUnpackedExtension(hidpi_path, &pack);
     ASSERT_TRUE(pack->WriteToDisk(file));
     VerifyHiDpiTheme(pack.get());
   }
 
   // Part 2: Try to read back the data pack that we just wrote to disk.
   {
     scoped_refptr<BrowserThemePack> pack =
         BrowserThemePack::BuildFromDataPack(file, "gllekhaobjnhgeag");
     ASSERT_TRUE(pack.get());
     VerifyHiDpiTheme(pack.get());
   }
 }