Unpack theme data from extensions off of UI thread.

chrome/browser/themes/browser_theme_pack.h

 // 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.
 
 #ifndef CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_
 #define CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 35 matching lines @@
 // BuildFromExtension() interface, we WriteToDisk() on a thread other than the
 // UI thread that consumes a BrowserThemePack. There is no locking; thread
 // safety between the writing thread and the UI thread is ensured by having the
 // data be immutable.
 //
 // BrowserThemePacks are always deleted on the file thread because in the
 // common case, they are backed by mmapped data and the unmmapping operation
 // will trip our IO on the UI thread detector.
 class BrowserThemePack : public CustomThemeSupplier {
  public:
-  // Builds the theme pack from all data from |extension|. This is often done
-  // on a separate thread as it takes so long. This can fail and return NULL in
-  // the case where the theme has invalid data.
-  static scoped_refptr<BrowserThemePack> BuildFromExtension(
-      const extensions::Extension* extension);
+  // Builds the theme from |extension| into |pack|. This may be done on a
+  // separate thread as it takes so long. This can fail in the case where the
+  // theme has invalid data, in which case |pack->is_valid()| will be false.
+  static void BuildFromExtension(const extensions::Extension* extension,
+                                 scoped_refptr<BrowserThemePack> pack);
 
   // Builds the theme pack from a previously performed WriteToDisk(). This
   // operation should be relatively fast, as it should be an mmap() and some
   // pointer swizzling. Returns NULL on any error attempting to read |path|.
   static scoped_refptr<BrowserThemePack> BuildFromDataPack(
       const base::FilePath& path, const std::string& expected_id);
 
   // Returns whether the specified identifier is one of the images we persist
   // in the data pack.
   static bool IsPersistentImageID(int id);
 
+  // Default. Everything is empty.
+  BrowserThemePack();
+
+  bool is_valid() const { return is_valid_; }
+
   // Builds a data pack on disk at |path| for future quick loading by
   // BuildFromDataPack(). Often (but not always) called from the file thread;
   // implementation should be threadsafe because neither thread will write to
   // |image_memory_| and the worker thread will keep a reference to prevent
   // destruction.
   bool WriteToDisk(const base::FilePath& path) const;
 
   // Overridden from CustomThemeSupplier:
   bool GetTint(int id, color_utils::HSL* hsl) const override;
   bool GetColor(int id, SkColor* color) const override;
@@ skipping 14 matching lines @@
 
   // The type passed to ui::DataPack::WritePack.
   typedef std::map<uint16_t, base::StringPiece> RawDataForWriting;
 
   // Maps scale factors (enum values) to file paths.
   typedef std::map<ui::ScaleFactor, base::FilePath> ScaleFactorToFileMap;
 
   // Maps image ids to maps of scale factors to file paths.
   typedef std::map<int, ScaleFactorToFileMap> FilePathMap;
 
-  // Default. Everything is empty.
-  BrowserThemePack();
-
   ~BrowserThemePack() override;
 
   // Builds a header ready to write to disk.
   void BuildHeader(const extensions::Extension* extension);
 
   // Transforms the JSON tint values into their final versions in the |tints_|
   // array.
   void BuildTintsFromJSON(const base::DictionaryValue* tints_value);
 
   // Transforms the JSON color values into their final versions in the
@@ skipping 91 matching lines @@
   // Header that is written to disk.
   struct BrowserThemePackHeader {
     // Numeric version to make sure we're compatible in the future.
     int32_t version;
 
     // 1 if little_endian. 0 if big_endian. On mismatch, abort load.
     int32_t little_endian;
 
     // theme_id without NULL terminator.
     uint8_t theme_id[16];
-  } *header_;
+  }* header_ = nullptr;
 
   // The remaining structs represent individual entries in an array. For the
   // following three structs, BrowserThemePack will either allocate an array or
   // will point directly to mmapped data.
   struct TintEntry {
     int32_t id;
     double h;
     double s;
     double l;
-  } *tints_;
+  }* tints_ = nullptr;
 
   struct ColorPair {
     int32_t id;
     SkColor color;
-  } *colors_;
+  }* colors_ = nullptr;
 
   struct DisplayPropertyPair {
     int32_t id;
     int32_t property;
-  } *display_properties_;
+  }* display_properties_ = nullptr;
 
   // A list of included source images. A pointer to a -1 terminated array of
   // our persistent IDs.
-  int* source_images_;
+  int* source_images_ = nullptr;
 #pragma pack(pop)
 
   // The scale factors represented by the images in the theme pack.
   std::vector<ui::ScaleFactor> scale_factors_;
 
   // References to raw PNG data. This map isn't touched when |data_pack_| is
   // non-NULL; |image_memory_| is only filled during BuildFromExtension(). Any
   // image data that needs to be written to the DataPack during WriteToDisk()
   // needs to be in |image_memory_|.
   RawImages image_memory_;
 
   // Loaded images. These are loaded from |image_memory_|, from |data_pack_|,
-  // and by BuildFromExtension(). These images should only be accessed on the UI
-  // thread.
-  ImageCache images_on_ui_thread_;
+  // and by BuildFromExtension().
+  ImageCache images_;
 
   // Cache of images created in BuildFromExtension(). Once the theme pack is
   // created, this cache should only be accessed on the file thread. There
   // should be no IDs in |image_memory_| that are in |images_on_file_thread_|
   // or vice versa.
   ImageCache images_on_file_thread_;
 
+  // Whether the theme pack has been succesfully initialized and is ready to
+  // use.
+  bool is_valid_ = false;
+
   DISALLOW_COPY_AND_ASSIGN(BrowserThemePack);
 };
 
 #endif  // CHROME_BROWSER_THEMES_BROWSER_THEME_PACK_H_