Move ThemeHandler from c/c/e/api; move GetBrowserImages() out of Extension class

chrome/common/extensions/extension_file_util.cc

 // Copyright (c) 2013 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/common/extensions/extension_file_util.h"
 
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/extensions/api/extension_action/action_info.h"
+#include "chrome/common/extensions/api/icons/icons_handler.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_l10n_util.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
+#include "chrome/common/extensions/manifest_handlers/theme_handler.h"
 #include "chrome/common/extensions/message_bundle.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_resource.h"
 #include "extensions/common/install_warning.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/file_stream.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using extensions::Extension;
 using extensions::ExtensionResource;
 using extensions::Manifest;
 
 namespace errors = extension_manifest_errors;
 
 namespace {
 
 const base::FilePath::CharType kTempDirectoryName[] = FILE_PATH_LITERAL("Temp");
 
+// Add the image paths contained in the |icon_set| to |image_paths|.
+void AddPathsFromIconSet(const ExtensionIconSet& icon_set,
+                         std::set<base::FilePath>* image_paths) {
+  // TODO(viettrungluu): These |FilePath::FromWStringHack(UTF8ToWide())|
+  // indicate that we're doing something wrong.
+  for (ExtensionIconSet::IconMap::const_iterator iter = icon_set.map().begin();
+       iter != icon_set.map().end(); ++iter) {
+    image_paths->insert(
+        base::FilePath::FromWStringHack(UTF8ToWide(iter->second)));

[Yoyo Zhou, 2013/04/10 21:44:58]

Seems like we should be using FromUTF8Unsafe instead. viettrungluu, do you
agree?

[Devlin, 2013/04/12 02:17:06]

Done (will change if viettrungluu would prefer something else).

I was wondering if we wanted to change ExtensionIconSet::IconMap to use either
FilePaths or FilePath::StringTypes.  In either case, if we do this, when we load
from the dictionary (LoadIconsFromDictionary()), we can do:

FilePath::StringType icon_path;
icons_dict->GetString(key, &icon_path);
icon_map->Add(icon_size, [icon_path | FilePath(icon_path)]);

If this sounds good, I'll handle it in a subsequent CL.

[viettrungluu, 2013/04/12 22:33:15]

Yes, I agree (assuming that we know for sure that iter->second really is UTF-8).

+  }
+}
+
 }  // namespace
 
 namespace extension_file_util {
 
 base::FilePath InstallExtension(const base::FilePath& unpacked_source_dir,
                                 const std::string& id,
                                 const std::string& version,
                                 const base::FilePath& extensions_dir) {
   base::FilePath extension_dir = extensions_dir.AppendASCII(id);
   base::FilePath version_dir;
@@ skipping 214 matching lines @@
           extensions::InstallWarning::FORMAT_TEXT,
           l10n_util::GetStringFUTF8(
               IDS_EXTENSION_CONTAINS_PRIVATE_KEY,
               private_keys[i].LossyDisplayName())));
     }
     // Only warn; don't block loading the extension.
   }
   return true;
 }
 
+std::set<base::FilePath> GetExtensionBrowserImages(const Extension* extension) {
+  std::set<base::FilePath> image_paths;
+
+  AddPathsFromIconSet(extensions::IconsInfo::GetIcons(extension), &image_paths);
+
+  // Theme images
+  const base::DictionaryValue* theme_images =
+      extensions::ThemeInfo::GetImages(extension);
+  if (theme_images) {
+    for (base::DictionaryValue::Iterator it(*theme_images); !it.IsAtEnd();
+         it.Advance()) {
+      base::FilePath::StringType path;
+      if (it.value().GetAsString(&path))
+        image_paths.insert(base::FilePath(path));
+    }
+  }
+
+  const extensions::ActionInfo* page_action =
+      extensions::ActionInfo::GetPageActionInfo(extension);
+  if (page_action && !page_action->default_icon.empty())
+    AddPathsFromIconSet(page_action->default_icon, &image_paths);
+
+  const extensions::ActionInfo* browser_action =
+      extensions::ActionInfo::GetBrowserActionInfo(extension);
+  if (browser_action && !browser_action->default_icon.empty())
+    AddPathsFromIconSet(browser_action->default_icon, &image_paths);
+
+  return image_paths;
+}
+
 void GarbageCollectExtensions(
     const base::FilePath& install_directory,
     const std::multimap<std::string, base::FilePath>& extension_paths) {
   // Nothing to clean up if it doesn't exist.
   if (!file_util::DirectoryExists(install_directory))
     return;
 
   DVLOG(1) << "Garbage collecting extensions...";
   file_util::FileEnumerator enumerator(install_directory,
                                        false,  // Not recursive.
@@ skipping 238 matching lines @@
     return base::FilePath();
   }
   return temp_path;
 }
 
 void DeleteFile(const base::FilePath& path, bool recursive) {
   file_util::Delete(path, recursive);
 }
 
 }  // namespace extension_file_util