Add new ResourceBundle::Delegate interface.

ui/base/resource/resource_bundle.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 UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 #define UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_
 #pragma once
 
 #include "build/build_config.h"
 
 #include <map>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/string16.h"
 #include "base/string_piece.h"
 #include "ui/base/ui_export.h"
+#include "ui/gfx/font.h"
+#include "ui/gfx/image/image.h"
 #include "ui/gfx/native_widget_types.h"
 
 class SkBitmap;
 
 namespace base {
 class Lock;
 class RefCountedStaticMemory;
 }
 
-namespace gfx {
-class Font;
-class Image;
-}
-
 namespace ui {
 
 class ResourceHandle;
 
 // ResourceBundle is a central facility to load images and other resources,
 // such as theme graphics. Every resource is loaded only once.
 class UI_EXPORT ResourceBundle {
  public:
   // An enumeration of the various font styles used throughout Chrome.
   // The following holds true for the font sizes:
@@ skipping 10 matching lines @@
     LargeBoldFont,
   };
 
   enum ImageRTL {
     // Images are flipped in RTL locales.
     RTL_ENABLED,
     // Images are never flipped.
     RTL_DISABLED,
   };
 
-  // Initialize the ResourceBundle for this process.  Returns the language
-  // selected.
+  class Delegate {

[tony, 2012/05/02 20:41:20]

Are delegates expected to deal with thread safety on their own?  In Chrome, we
allow calls to load resources/strings from any thread.  I'm not sure if this is
an issue for content_shell or ash.

[Marshall, 2012/05/03 19:10:54]

Yes, the delegate will need to deal with thread safety issues. I've added a
comment in the head to that effect.

+   public:
+    // Retrieve the full path for the specified |pack_name|. |pack_path| will
+    // initially contain the default path for the pack file. Change it in this
+    // callback if a different path is desired. Return true to continue loading
+    // the pack file or false to cancel the load.
+    virtual bool GetPathForResourcePack(const std::string& pack_name,
+                                        FilePath* pack_path,
+                                        float scale_factor) = 0;

[tony, 2012/05/02 20:41:20]

I would keep pack_name as a FilePath.  What if we wanted to load a pack_name
with non-ascii in it? Out parameters (pack_path) should come last.

[Marshall, 2012/05/03 19:10:54]

Done.

+
+    // Retrieve the full path for the specified |locale|. |pack_path| will
+    // initially contain the default path for the pack file. Change it in this
+    // callback if a different path is desired. Return true to continue loading
+    // the pack file or false to cancel the load.
+    virtual bool GetPathForLocalePack(const std::string& locale,
+                                      FilePath* pack_path) = 0;

[tony, 2012/05/02 20:41:20]

I would just return a FilePath (empty to cancel the load).  If the delegate
doesn't want to change it, it returns the pack_path passed in.

Maybe you would do the same with GetPathForResourcePack, but it's a bit
different since the "do nothing" case means appending pack_name to pack_path.

[Marshall, 2012/05/03 19:10:54]

Done.

+
+    // Return an image resource or NULL to attempt retrieval of the default
+    // resource.
+    virtual scoped_ptr<gfx::Image> GetImageNamed(int resource_id) = 0;
+
+    // Return an image resource or NULL to attempt retrieval of the default
+    // resource.
+    virtual scoped_ptr<gfx::Image> GetNativeImageNamed(int resource_id,
+                                                       ImageRTL rtl) = 0;
+
+    // Return a static memory resource or NULL to attempt retrieval of the
+    // default resource.
+    virtual base::RefCountedStaticMemory* LoadDataResourceBytes(
+        int resource_id) = 0;
+
+    // Retrieve a raw data resource. Return true if a resource was provided or
+    // false to attempt retrieval of the default resource.
+    virtual bool GetRawDataResource(int resource_id,
+                                    base::StringPiece* value) = 0;
+
+    // Retrieve a localized string. Return true if a string was provided or
+    // false to attempt retrieval of the default string.
+    virtual bool GetLocalizedString(int message_id, string16* value) = 0;
+
+    // Return a font resource or NULL to attempt retrieval of the default
+    // resource.
+    virtual scoped_ptr<gfx::Font> GetFont(FontStyle style) = 0;
+
+   protected:
+    virtual ~Delegate() {}
+  };
+
+  // Initialize the ResourceBundle for this process. Does not take ownership of
+  // the |delegate| value. Returns the language selected.
   // NOTE: Mac ignores this and always loads up resources for the language
   // defined by the Cocoa UI (i.e., NSBundle does the language work).
   static std::string InitSharedInstanceWithLocale(
-      const std::string& pref_locale);
+      const std::string& pref_locale, Delegate* delegate);
 
   // Initialize the ResourceBundle using given data pack path for testing.
   static void InitSharedInstanceWithPakFile(const FilePath& path);
 
   // Delete the ResourceBundle for this process if it exists.
   static void CleanupSharedInstance();
 
   // Returns true after the global resource loader instance has been created.
   static bool HasSharedInstance();
 
   // Return the global resource loader instance.
   static ResourceBundle& GetSharedInstance();
 
   // Check if the .pak for the given locale exists.
-  static bool LocaleDataPakExists(const std::string& locale);
+  bool LocaleDataPakExists(const std::string& locale);

[tony, 2012/05/02 20:41:20]

Does this need to be public?

[Marshall, 2012/05/03 19:10:54]

It's used by l10n_util.cc currently.

 
-  // Registers additional data pack files with the global ResourceBundle.  When
-  // looking for a DataResource, we will search these files after searching the
-  // main module. |scale_factor| is the scale of images in this resource pak
-  // relative to the images in the 1x resource pak. This method is not thread
-  // safe! You should call it immediately after calling InitSharedInstance.
-  void AddDataPack(const FilePath& path, float scale_factor);
+  // Registers additional data pack files with the ResourceBundle.  When looking
+  // for a DataResource, we will search these files after searching the main
+  // module. |pack_name| is the name of the pack file (minus the extension)
+  // that will be passed to the delegate. |scale_factor| is the scale of images
+  // in this resource pak relative to the images in the 1x resource pak. This
+  // method is not thread safe! You should call it immediately after calling
+  // InitSharedInstance.
+  void AddDataPack(const std::string& pack_name,

[tony, 2012/05/02 20:41:20]

I would leave this interface unchanged and and split the path into filename and
directory pieces in the function itself.  Should be less code churn.

[Marshall, 2012/05/03 19:10:54]

Done.

+                   const FilePath& path,
+                   float scale_factor);
 
   // Changes the locale for an already-initialized ResourceBundle, returning the
   // name of the newly-loaded locale.  Future calls to get strings will return
   // the strings for this new locale.  This has no effect on existing or future
   // image resources.  |locale_resources_data_| is protected by a lock for the
   // duration of the swap, as GetLocalizedString() may be concurrently invoked
   // on another thread.
   std::string ReloadLocaleResources(const std::string& pref_locale);
 
   // Gets the bitmap with the specified resource_id from the current module
@@ skipping 38 matching lines @@
 
   // Resets and reloads the cached fonts.  This is useful when the fonts of the
   // system have changed, for example, when the locale has changed.
   void ReloadFonts();
 
   // Overrides the path to the pak file from which the locale resources will be
   // loaded. Pass an empty path to undo.
   void OverrideLocalePakForTest(const FilePath& pak_path);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetPathForResourcePack);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetPathForLocalePack);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetImageNamed);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetNativeImageNamed);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateLoadDataResourceBytes);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetRawDataResource);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetLocalizedString);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, DelegateGetFont);
   FRIEND_TEST_ALL_PREFIXES(ResourceBundle, LoadDataResourceBytes);
+  FRIEND_TEST_ALL_PREFIXES(ResourceBundle, LocaleDataPakExists);
 
   // Ctor/dtor are private, since we're a singleton.
-  ResourceBundle();
+  explicit ResourceBundle(Delegate* delegate);
   ~ResourceBundle();
 
   // Free skia_images_.
   void FreeImages();
 
   // Load the main resources.
   void LoadCommonResources();
 
   // Try to load the locale specific strings from an external data module.
   // Returns the locale that is loaded.
   std::string LoadLocaleResources(const std::string& pref_locale);
 
   // Load test resources in given path.
   void LoadTestResources(const FilePath& path);
 
   // Unload the locale specific strings and prepares to load new ones. See
   // comments for ReloadLocaleResources().
   void UnloadLocaleResources();
 
   // Initialize all the gfx::Font members if they haven't yet been initialized.
   void LoadFontsIfNecessary();
 
   // Returns the full pathname of the locale file to load.  May return an empty
   // string if no locale data files are found.
-  static FilePath GetLocaleFilePath(const std::string& app_locale);
+  FilePath GetLocaleFilePath(const std::string& app_locale);
 
   // Creates and returns a new SkBitmap given the data file to look in and the
   // resource id.  It's up to the caller to free the returned bitmap when
   // done.
   SkBitmap* LoadBitmap(const ResourceHandle& dll_inst, int resource_id);
 
   // Returns an empty image for when a resource cannot be loaded. This is a
   // bright red bitmap.
   gfx::Image* GetEmptyImage();
 
   const FilePath& GetOverriddenPakPath();
 
+  // This pointer is guaranteed to outlive the ResourceBundle instance.

[tony, 2012/05/02 20:41:20]

I would add that it can be NULL.

[Marshall, 2012/05/03 19:10:54]

Done.

+  Delegate* delegate_;
+
   // Protects |images_| and font-related members.
   scoped_ptr<base::Lock> images_and_fonts_lock_;
 
   // Protects |locale_resources_data_|.
   scoped_ptr<base::Lock> locale_resources_data_lock_;
 
   // Handles for data sources.
   scoped_ptr<ResourceHandle> locale_resources_data_;
   ScopedVector<ResourceHandle> data_packs_;
 
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ResourceBundle);
 };
 
 }  // namespace ui
 
 // TODO(beng): Someday, maybe, get rid of this.
 using ui::ResourceBundle;
 
 #endif  // UI_BASE_RESOURCE_RESOURCE_BUNDLE_H_