Kill Extension::RuntimeData and move its guts to ExtensionsService.

chrome/common/extensions/extension.cc

 // Copyright (c) 2010 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.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
@@ skipping 231 matching lines @@
   Extension::kUnlimitedStoragePermission,
   Extension::kWebstorePrivatePermission,
 };
 const size_t Extension::kNumHostedAppPermissions =
     arraysize(Extension::kHostedAppPermissionNames);
 
 // We purposefully don't put this into kPermissionNames.
 const char Extension::kOldUnlimitedStoragePermission[] = "unlimited_storage";
 
 //
-// Extension::RuntimeData
+// Extension
 //
 
-Extension::RuntimeData::RuntimeData()
-    : background_page_ready(false),
-      being_upgraded(false) {
-}
-
-Extension::RuntimeData::~RuntimeData() {
+// static
 }
 
 //
 // Extension
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
                                            Location location,
                                            const DictionaryValue& value,
@@ skipping 1651 matching lines @@
   return image_paths;
 }
 
 GURL Extension::GetFullLaunchURL() const {
   if (!launch_local_path().empty())
     return url().Resolve(launch_local_path());
   else
     return GURL(launch_web_url());
 }
 
-bool Extension::GetBackgroundPageReady() const {
-  return (GetRuntimeData()->background_page_ready ||
-          background_url().is_empty());
-}
-
-void Extension::SetBackgroundPageReady() const {
-  DCHECK(!background_url().is_empty());
-  GetRuntimeData()->background_page_ready = true;
-  NotificationService::current()->Notify(
-      NotificationType::EXTENSION_BACKGROUND_PAGE_READY,
-      Source<Extension>(this),
-      NotificationService::NoDetails());
-}
-
 static std::string SizeToString(const gfx::Size& max_size) {
   return base::IntToString(max_size.width()) + "x" +
          base::IntToString(max_size.height());
 }
 
 // static
 void Extension::SetScriptingWhitelist(
     const std::vector<std::string>& whitelist) {
   ScriptingWhitelist* current_whitelist =
       ExtensionConfig::GetSingleton()->whitelist();
   current_whitelist->clear();
   for (ScriptingWhitelist::const_iterator it = whitelist.begin();
        it != whitelist.end(); ++it) {
     current_whitelist->push_back(*it);
   }
 }
 
 void Extension::SetCachedImage(const ExtensionResource& source,
                                const SkBitmap& image,
                                const gfx::Size& original_size) const {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
   const FilePath& path = source.relative_path();
   gfx::Size actual_size(image.width(), image.height());
   if (actual_size == original_size) {
-    GetRuntimeData()->image_cache_[
-        RuntimeData::ImageCacheKey(path, std::string())] = image;
+    image_cache_[ImageCacheKey(path, std::string())] = image;
   } else {
-    GetRuntimeData()->image_cache_[
-        RuntimeData::ImageCacheKey(path, SizeToString(actual_size))] = image;
+    image_cache_[ImageCacheKey(path, SizeToString(actual_size))] = image;
   }
 }
 
 bool Extension::HasCachedImage(const ExtensionResource& source,
                                const gfx::Size& max_size) const {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
   return GetCachedImageImpl(source, max_size) != NULL;
 }
 
 SkBitmap Extension::GetCachedImage(const ExtensionResource& source,
                                    const gfx::Size& max_size) const {
   DCHECK(source.extension_root() == path());  // The resource must come from
                                               // this extension.
   SkBitmap* image = GetCachedImageImpl(source, max_size);
   return image ? *image : SkBitmap();
 }
 
 SkBitmap* Extension::GetCachedImageImpl(const ExtensionResource& source,
                                         const gfx::Size& max_size) const {
   const FilePath& path = source.relative_path();
 
   // Look for exact size match.
-  RuntimeData::ImageCache::iterator i = GetRuntimeData()->image_cache_.find(
-      RuntimeData::ImageCacheKey(path, SizeToString(max_size)));
-  if (i != GetRuntimeData()->image_cache_.end())
+  ImageCache::iterator i = image_cache_.find(
+      ImageCacheKey(path, SizeToString(max_size)));
+  if (i != image_cache_.end())
     return &(i->second);
 
   // If we have the original size version cached, return that if it's small
   // enough.
-  i = GetRuntimeData()->image_cache_.find(
-      RuntimeData::ImageCacheKey(path, std::string()));
-  if (i != GetRuntimeData()->image_cache_.end()) {
+  i = image_cache_.find(ImageCacheKey(path, std::string()));
+  if (i != image_cache_.end()) {
     SkBitmap& image = i->second;
     if (image.width() <= max_size.width() &&
         image.height() <= max_size.height())
       return &(i->second);
   }
 
   return NULL;
 }
 
 ExtensionResource Extension::GetIconResource(
@@ skipping 198 matching lines @@
   for (ScriptingWhitelist::const_iterator it = whitelist->begin();
        it != whitelist->end(); ++it) {
     if (id() == *it) {
       return true;
     }
   }
 
   return false;
 }
 
-Extension::RuntimeData* Extension::GetRuntimeData() const {
-  // TODO(mpcomplete): it would be nice if I could verify we were on the UI
-  // thread, but we're in common and don't have access to BrowserThread.
-  return const_cast<Extension::RuntimeData*>(&runtime_data_);
-}
-
 ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
                              const std::string& id,
                              const FilePath& path,
                              Extension::Location location)
     : extension_id(id),
       extension_path(path),
       extension_location(location) {
   if (manifest)
     extension_manifest.reset(
         static_cast<DictionaryValue*>(manifest->DeepCopy()));
 }
 
 ExtensionInfo::~ExtensionInfo() {}
 
 UninstalledExtensionInfo::UninstalledExtensionInfo(
     const Extension& extension)
     : extension_id(extension.id()),
       extension_api_permissions(extension.api_permissions()),
       is_theme(extension.is_theme()),
       is_app(extension.is_app()),
       converted_from_user_script(extension.converted_from_user_script()),
       update_url(extension.update_url()) {}
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}