Refactor ChromeURLRequestContext to pull out ExtensionInfoMap into a shared

data structure that all the different contexts have a handle to.

BUG=56558
TEST=no functional change

Review URL: http://codereview.chromium.org/3439017

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@61120 0039d316-1c4b-4281-b951-d872f2087c98

24 files changed, 623 insertions, 438 deletions

diff --git a/chrome/browser/extensions/extension_info_map.cc b/chrome/browser/extensions/extension_info_map.cc
new file mode 100644
index 0000000..997dea3
--- /dev/null
+++ b/chrome/browser/extensions/extension_info_map.cc
@@ -0,0 +1,131 @@
+// 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/browser/extensions/extension_info_map.h"
+
+#include "chrome/browser/chrome_thread.h"
+#include "chrome/common/url_constants.h"
+
+namespace {
+
+static void CheckOnValidThread() {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
+}
+
+}  // namespace
+
+ExtensionInfoMap::ExtensionInfoMap() {
+}
+
+ExtensionInfoMap::~ExtensionInfoMap() {
+}
+
+void ExtensionInfoMap::AddExtension(const Extension::StaticData* data) {
+  CheckOnValidThread();
+  extension_info_[data->id] = data;
+
+  // Our map has already added a reference. Balance the reference given at the
+  // call-site.
+  data->Release();
+}
+
+void ExtensionInfoMap::RemoveExtension(const std::string& id) {
+  CheckOnValidThread();
+  Map::iterator iter = extension_info_.find(id);
+  if (iter != extension_info_.end()) {
+    extension_info_.erase(iter);
+  } else {
+    // NOTE: This can currently happen if we receive multiple unload
+    // notifications, e.g. setting incognito-enabled state for a
+    // disabled extension (e.g., via sync).  See
+    // http://code.google.com/p/chromium/issues/detail?id=50582 .
+    NOTREACHED() << id;
+  }
+}
+
+
+std::string ExtensionInfoMap::GetNameForExtension(const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  if (iter != extension_info_.end())
+    return iter->second->name;
+  else
+    return std::string();
+}
+
+FilePath ExtensionInfoMap::GetPathForExtension(const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  if (iter != extension_info_.end())
+    return iter->second->path;
+  else
+    return FilePath();
+}
+
+bool ExtensionInfoMap::ExtensionHasWebExtent(const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  return iter != extension_info_.end() && !iter->second->extent.is_empty();
+}
+
+bool ExtensionInfoMap::ExtensionCanLoadInIncognito(
+    const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  // Only split-mode extensions can load in incognito profiles.
+  return iter != extension_info_.end() && iter->second->incognito_split_mode;
+}
+
+std::string ExtensionInfoMap::GetDefaultLocaleForExtension(
+    const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  std::string result;
+  if (iter != extension_info_.end())
+    result = iter->second->default_locale;
+
+  return result;
+}
+
+ExtensionExtent ExtensionInfoMap::GetEffectiveHostPermissionsForExtension(
+    const std::string& id) const {
+  Map::const_iterator iter = extension_info_.find(id);
+  ExtensionExtent result;
+  if (iter != extension_info_.end())
+    result = iter->second->effective_host_permissions;
+
+  return result;
+}
+
+bool ExtensionInfoMap::CheckURLAccessToExtensionPermission(
+    const GURL& url,
+    const char* permission_name) const {
+  Map::const_iterator info;
+  if (url.SchemeIs(chrome::kExtensionScheme)) {
+    // If the url is an extension scheme, we just look it up by extension id.
+    std::string id = url.host();
+    info = extension_info_.find(id);
+  } else {
+    // Otherwise, we scan for a matching extent. Overlapping extents are
+    // disallowed, so only one will match.
+    info = extension_info_.begin();
+    while (info != extension_info_.end() &&
+           !info->second->extent.ContainsURL(url))
+      ++info;
+  }
+
+  if (info == extension_info_.end())
+    return false;
+
+  const std::set<std::string>& api_permissions = info->second->api_permissions;
+  return api_permissions.count(permission_name) != 0;
+}
+
+bool ExtensionInfoMap::URLIsForExtensionIcon(const GURL& url) const {
+  DCHECK(url.SchemeIs(chrome::kExtensionScheme));
+
+  Map::const_iterator iter = extension_info_.find(url.host());
+  if (iter == extension_info_.end())
+    return false;
+
+  std::string path = url.path();
+  DCHECK(path.length() > 0 && path[0] == '/');
+  path = path.substr(1);
+  return iter->second->icons.ContainsPath(path);
+}
diff --git a/chrome/browser/extensions/extension_info_map.h b/chrome/browser/extensions/extension_info_map.h
new file mode 100644
index 0000000..fb03162
--- /dev/null
+++ b/chrome/browser/extensions/extension_info_map.h
@@ -0,0 +1,72 @@
+// 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.
+
+#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_INFO_MAP_H_
+#define CHROME_BROWSER_EXTENSIONS_EXTENSION_INFO_MAP_H_
+#pragma once
+
+#include <map>
+#include <string>
+
+#include "base/basictypes.h"
+#include "base/file_path.h"
+#include "base/ref_counted.h"
+#include "chrome/common/extensions/extension.h"
+#include "googleurl/src/gurl.h"
+
+// Contains extension data that needs to be accessed on the IO thread. It can
+// be created/destroyed on any thread, but all other methods must be called on
+// the IO thread.
+//
+// TODO(mpcomplete): consider simplifying this class to return the StaticData
+// object itself, since most methods are simple property accessors.
+class ExtensionInfoMap : public base::RefCountedThreadSafe<ExtensionInfoMap> {
+ public:
+  ExtensionInfoMap();
+  ~ExtensionInfoMap();
+
+  // Callback for when new extensions are loaded.
+  void AddExtension(const Extension::StaticData* data);
+
+  // Callback for when an extension is unloaded.
+  void RemoveExtension(const std::string& id);
+
+  // Gets the name for the specified extension.
+  std::string GetNameForExtension(const std::string& id) const;
+
+  // Gets the path to the directory for the specified extension.
+  FilePath GetPathForExtension(const std::string& id) const;
+
+  // Returns true if the specified extension exists and has a non-empty web
+  // extent.
+  bool ExtensionHasWebExtent(const std::string& id) const;
+
+  // Returns true if the specified extension exists and can load in incognito
+  // contexts.
+  bool ExtensionCanLoadInIncognito(const std::string& id) const;
+
+  // Returns an empty string if the extension with |id| doesn't have a default
+  // locale.
+  std::string GetDefaultLocaleForExtension(const std::string& id) const;
+
+  // Gets the effective host permissions for the extension with |id|.
+  ExtensionExtent
+      GetEffectiveHostPermissionsForExtension(const std::string& id) const;
+
+  // Determine whether a URL has access to the specified extension permission.
+  bool CheckURLAccessToExtensionPermission(const GURL& url,
+                                           const char* permission_name) const;
+
+  // Returns true if the specified URL references the icon for an extension.
+  bool URLIsForExtensionIcon(const GURL& url) const;
+
+ private:
+  // Map of extension info by extension id.
+  typedef std::map<std::string, scoped_refptr<const Extension::StaticData> >
+      Map;
+
+  Map extension_info_;
+};
+
+#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_INFO_MAP_H_
diff --git a/chrome/browser/extensions/extension_info_map_unittest.cc b/chrome/browser/extensions/extension_info_map_unittest.cc
new file mode 100644
index 0000000..e521603
--- /dev/null
+++ b/chrome/browser/extensions/extension_info_map_unittest.cc
@@ -0,0 +1,171 @@
+// 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 "base/message_loop.h"
+#include "base/path_service.h"
+#include "chrome/browser/chrome_thread.h"
+#include "chrome/browser/extensions/extension_info_map.h"
+#include "chrome/common/chrome_paths.h"
+#include "chrome/common/json_value_serializer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace keys = extension_manifest_keys;
+
+namespace {
+
+class ExtensionInfoMapTest : public testing::Test {
+ public:
+  ExtensionInfoMapTest()
+      : ui_thread_(ChromeThread::UI, &message_loop_),
+        io_thread_(ChromeThread::IO, &message_loop_) {
+  }
+
+ private:
+  MessageLoop message_loop_;
+  ChromeThread ui_thread_;
+  ChromeThread io_thread_;
+};
+
+// Returns a barebones test Extension object with the given name.
+static Extension* CreateExtension(const std::string& name) {
+#if defined(OS_WIN)
+  FilePath path(FILE_PATH_LITERAL("c:\\foo"));
+#elif defined(OS_POSIX)
+  FilePath path(FILE_PATH_LITERAL("/foo"));
+#endif
+
+  scoped_ptr<Extension> extension(new Extension(path.AppendASCII(name)));
+
+  DictionaryValue manifest;
+  manifest.SetString(keys::kVersion, "1.0.0.0");
+  manifest.SetString(keys::kName, name);
+
+  std::string error;
+  EXPECT_TRUE(extension->InitFromValue(manifest, false, &error)) << error;
+
+  return extension.release();
+}
+
+static Extension* LoadManifest(const std::string& dir,
+                               const std::string& test_file) {
+  FilePath path;
+  PathService::Get(chrome::DIR_TEST_DATA, &path);
+  path = path.AppendASCII("extensions")
+             .AppendASCII(dir)
+             .AppendASCII(test_file);
+
+  JSONFileValueSerializer serializer(path);
+  scoped_ptr<Value> result(serializer.Deserialize(NULL, NULL));
+  if (!result.get())
+    return NULL;
+
+  std::string error;
+  scoped_ptr<Extension> extension(new Extension(path));
+  EXPECT_TRUE(extension->InitFromValue(
+      *static_cast<DictionaryValue*>(result.get()), false, &error)) << error;
+
+  return extension.release();
+}
+
+}  // namespace
+
+// Test that the ExtensionInfoMap handles refcounting properly.
+TEST_F(ExtensionInfoMapTest, RefCounting) {
+  scoped_refptr<ExtensionInfoMap> info_map(new ExtensionInfoMap());
+
+  // New extensions should have a single reference holding onto their static
+  // data.
+  scoped_ptr<Extension> extension1(CreateExtension("extension1"));
+  scoped_ptr<Extension> extension2(CreateExtension("extension2"));
+  scoped_ptr<Extension> extension3(CreateExtension("extension3"));
+  EXPECT_TRUE(extension1->static_data()->HasOneRef());
+  EXPECT_TRUE(extension2->static_data()->HasOneRef());
+  EXPECT_TRUE(extension3->static_data()->HasOneRef());
+
+  // Add a ref to each extension and give it to the info map. The info map
+  // expects the caller to add a ref for it, but then assumes ownership of that
+  // reference.
+  extension1->static_data()->AddRef();
+  info_map->AddExtension(extension1->static_data());
+  extension2->static_data()->AddRef();
+  info_map->AddExtension(extension2->static_data());
+  extension3->static_data()->AddRef();
+  info_map->AddExtension(extension3->static_data());
+
+  // Delete extension1, and the info map should have the only ref.
+  const Extension::StaticData* data1 = extension1->static_data();
+  extension1.reset();
+  EXPECT_TRUE(data1->HasOneRef());
+
+  // Remove extension2, and the extension2 object should have the only ref.
+  info_map->RemoveExtension(extension2->id());
+  EXPECT_TRUE(extension2->static_data()->HasOneRef());
+
+  // Delete the info map, and the extension3 object should have the only ref.
+  info_map = NULL;
+  EXPECT_TRUE(extension3->static_data()->HasOneRef());
+}
+
+// Tests that we can query a few extension properties from the ExtensionInfoMap.
+TEST_F(ExtensionInfoMapTest, Properties) {
+  scoped_refptr<ExtensionInfoMap> info_map(new ExtensionInfoMap());
+
+  scoped_ptr<Extension> extension1(CreateExtension("extension1"));
+  scoped_ptr<Extension> extension2(CreateExtension("extension2"));
+
+  extension1->static_data()->AddRef();
+  info_map->AddExtension(extension1->static_data());
+  extension2->static_data()->AddRef();
+  info_map->AddExtension(extension2->static_data());
+
+  EXPECT_EQ(extension1->name(),
+            info_map->GetNameForExtension(extension1->id()));
+  EXPECT_EQ(extension2->name(),
+            info_map->GetNameForExtension(extension2->id()));
+
+  EXPECT_EQ(extension1->path().value(),
+            info_map->GetPathForExtension(extension1->id()).value());
+  EXPECT_EQ(extension2->path().value(),
+            info_map->GetPathForExtension(extension2->id()).value());
+}
+
+// Tests CheckURLAccessToExtensionPermission given both extension and app URLs.
+TEST_F(ExtensionInfoMapTest, CheckPermissions) {
+  scoped_refptr<ExtensionInfoMap> info_map(new ExtensionInfoMap());
+
+  scoped_ptr<Extension> app(LoadManifest("manifest_tests",
+                                         "valid_app.json"));
+  scoped_ptr<Extension> extension(LoadManifest("manifest_tests",
+                                               "tabs_extension.json"));
+
+  GURL app_url("http://www.google.com/mail/foo.html");
+  ASSERT_TRUE(app->is_app());
+  ASSERT_TRUE(app->web_extent().ContainsURL(app_url));
+
+  app->static_data()->AddRef();
+  info_map->AddExtension(app->static_data());
+  extension->static_data()->AddRef();
+  info_map->AddExtension(extension->static_data());
+
+  // The app should have the notifications permission, either from a
+  // chrome-extension URL or from its web extent.
+  EXPECT_TRUE(info_map->CheckURLAccessToExtensionPermission(
+      app->GetResourceURL("a.html"), Extension::kNotificationPermission));
+  EXPECT_TRUE(info_map->CheckURLAccessToExtensionPermission(
+      app_url, Extension::kNotificationPermission));
+  EXPECT_FALSE(info_map->CheckURLAccessToExtensionPermission(
+      app_url, Extension::kTabPermission));
+
+  // The extension should have the tabs permission.
+  EXPECT_TRUE(info_map->CheckURLAccessToExtensionPermission(
+      extension->GetResourceURL("a.html"), Extension::kTabPermission));
+  EXPECT_FALSE(info_map->CheckURLAccessToExtensionPermission(
+      extension->GetResourceURL("a.html"), Extension::kNotificationPermission));
+
+  // Random URL should not have any permissions.
+  EXPECT_FALSE(info_map->CheckURLAccessToExtensionPermission(
+      GURL("http://evil.com/a.html"), Extension::kNotificationPermission));
+  EXPECT_FALSE(info_map->CheckURLAccessToExtensionPermission(
+      GURL("http://evil.com/a.html"), Extension::kTabPermission));
+}
diff --git a/chrome/browser/extensions/extension_protocols.cc b/chrome/browser/extensions/extension_protocols.cc
index 874b759..ce56589 100644
--- a/chrome/browser/extensions/extension_protocols.cc
+++ b/chrome/browser/extensions/extension_protocols.cc
@@ -91,8 +91,9 @@ bool AllowExtensionResourceLoad(URLRequest* request,
   // hybrid hosted/packaged apps. The one exception is access to icons, since
   // some extensions want to be able to do things like create their own
   // launchers.
-  if (context->ExtensionHasWebExtent(request->url().host())) {
-    if (!context->URLIsForExtensionIcon(request->url())) {
+  if (context->extension_info_map()->
+          ExtensionHasWebExtent(request->url().host())) {
+    if (!context->extension_info_map()->URLIsForExtensionIcon(request->url())) {
       LOG(ERROR) << "Denying load of " << request->url().spec() << " from "
                  << "hosted app.";
       return false;
@@ -104,7 +105,8 @@ bool AllowExtensionResourceLoad(URLRequest* request,
   // incognito tab prevents that.
   if (context->is_off_the_record() &&
       info->resource_type() == ResourceType::MAIN_FRAME &&
-      !context->ExtensionCanLoadInIncognito(request->url().host())) {
+      !context->extension_info_map()->
+          ExtensionCanLoadInIncognito(request->url().host())) {
     LOG(ERROR) << "Denying load of " << request->url().spec() << " from "
                << "incognito tab.";
     return false;
@@ -123,8 +125,8 @@ bool AllowExtensionResourceLoad(URLRequest* request,
       origin_url.SchemeIs(chrome::kDataScheme)) {
     return true;
   } else {
-    ExtensionExtent host_permissions =
-        context->GetEffectiveHostPermissionsForExtension(request->url().host());
+    ExtensionExtent host_permissions = context->extension_info_map()->
+        GetEffectiveHostPermissionsForExtension(request->url().host());
     if (host_permissions.ContainsURL(origin_url)) {
       return true;
     } else {
@@ -151,7 +153,8 @@ static URLRequestJob* CreateExtensionURLRequestJob(URLRequest* request,
 
   // chrome-extension://extension-id/resource/path.js
   const std::string& extension_id = request->url().host();
-  FilePath directory_path = context->GetPathForExtension(extension_id);
+  FilePath directory_path = context->extension_info_map()->
+      GetPathForExtension(extension_id);
   if (directory_path.value().empty()) {
     LOG(WARNING) << "Failed to GetPathForExtension: " << extension_id;
     return NULL;
diff --git a/chrome/browser/extensions/extensions_service.cc b/chrome/browser/extensions/extensions_service.cc
index 03699fa..0a0b980 100644
--- a/chrome/browser/extensions/extensions_service.cc
+++ b/chrome/browser/extensions/extensions_service.cc
@@ -889,21 +889,6 @@ void ExtensionsService::LoadComponentExtensions() {
       return;
     }
 
-    // In order for the --apps-gallery-url switch to work with the gallery
-    // process isolation, we must insert any provided value into the component
-    // app's launch url and web extent.
-    if (extension->id() == extension_misc::kWebStoreAppId) {
-      GURL gallery_url(CommandLine::ForCurrentProcess()
-          ->GetSwitchValueASCII(switches::kAppsGalleryURL));
-      if (gallery_url.is_valid()) {
-        extension->set_launch_web_url(gallery_url.spec());
-        URLPattern pattern(URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS);
-        pattern.Parse(gallery_url.spec());
-        pattern.set_path(pattern.path() + '*');
-        extension->web_extent().AddPattern(pattern);
-      }
-    }
-
     OnExtensionLoaded(extension.release(), false);  // Don't allow privilege
                                                     // increase.
   }
diff --git a/chrome/browser/net/chrome_url_request_context.cc b/chrome/browser/net/chrome_url_request_context.cc
index 88f8ee0..a9ed157 100644
--- a/chrome/browser/net/chrome_url_request_context.cc
+++ b/chrome/browser/net/chrome_url_request_context.cc
@@ -655,17 +655,6 @@ void ChromeURLRequestContextGetter::CleanupOnUIThread() {
   registrar_.RemoveAll();
 }
 
-void ChromeURLRequestContextGetter::OnNewExtensions(
-    const std::string& id,
-    ChromeURLRequestContext::ExtensionInfo* info) {
-  GetIOContext()->OnNewExtensions(id, info);
-}
-
-void ChromeURLRequestContextGetter::OnUnloadedExtension(
-    const std::string& id) {
-  GetIOContext()->OnUnloadedExtension(id);
-}
-
 // NotificationObserver implementation.
 void ChromeURLRequestContextGetter::Observe(
     NotificationType type,
@@ -784,117 +773,11 @@ ChromeURLRequestContext::~ChromeURLRequestContext() {
   cookie_policy_ = NULL;
 }
 
-std::string ChromeURLRequestContext::GetNameForExtension(
-    const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  if (iter != extension_info_.end())
-    return iter->second->name;
-  else
-    return std::string();
-}
-
-FilePath ChromeURLRequestContext::GetPathForExtension(const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  if (iter != extension_info_.end())
-    return iter->second->path;
-  else
-    return FilePath();
-}
-
-bool ChromeURLRequestContext::ExtensionHasWebExtent(const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  return iter != extension_info_.end() && !iter->second->extent.is_empty();
-}
-
-bool ChromeURLRequestContext::ExtensionCanLoadInIncognito(
-    const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  // Only split-mode extensions can load in incognito profiles.
-  return iter != extension_info_.end() && iter->second->incognito_split_mode;
-}
-
-std::string ChromeURLRequestContext::GetDefaultLocaleForExtension(
-    const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  std::string result;
-  if (iter != extension_info_.end())
-    result = iter->second->default_locale;
-
-  return result;
-}
-
-ExtensionExtent
-    ChromeURLRequestContext::GetEffectiveHostPermissionsForExtension(
-        const std::string& id) {
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  ExtensionExtent result;
-  if (iter != extension_info_.end())
-    result = iter->second->effective_host_permissions;
-
-  return result;
-}
-
-bool ChromeURLRequestContext::CheckURLAccessToExtensionPermission(
-    const GURL& url,
-    const char* permission_name) {
-  ExtensionInfoMap::iterator info;
-  if (url.SchemeIs(chrome::kExtensionScheme)) {
-    // If the url is an extension scheme, we just look it up by extension id.
-    std::string id = url.host();
-    info = extension_info_.find(id);
-  } else {
-    // Otherwise, we scan for a matching extent. Overlapping extents are
-    // disallowed, so only one will match.
-    info = extension_info_.begin();
-    while (info != extension_info_.end() &&
-           !info->second->extent.ContainsURL(url))
-      ++info;
-  }
-
-  if (info == extension_info_.end())
-    return false;
-
-  std::set<std::string>& api_permissions = info->second->api_permissions;
-  return api_permissions.count(permission_name) != 0;
-}
-
-bool ChromeURLRequestContext::URLIsForExtensionIcon(const GURL& url) {
-  DCHECK(url.SchemeIs(chrome::kExtensionScheme));
-
-  ExtensionInfoMap::iterator iter = extension_info_.find(url.host());
-  if (iter == extension_info_.end())
-    return false;
-
-  std::string path = url.path();
-  DCHECK(path.length() > 0 && path[0] == '/');
-  path = path.substr(1);
-  return iter->second->icons.ContainsPath(path);
-}
-
 const std::string& ChromeURLRequestContext::GetUserAgent(
     const GURL& url) const {
   return webkit_glue::GetUserAgent(url);
 }
 
-void ChromeURLRequestContext::OnNewExtensions(const std::string& id,
-                                              ExtensionInfo* info) {
-  extension_info_[id] = linked_ptr<ExtensionInfo>(info);
-}
-
-void ChromeURLRequestContext::OnUnloadedExtension(const std::string& id) {
-  CheckCurrentlyOnIOThread();
-  ExtensionInfoMap::iterator iter = extension_info_.find(id);
-  if (iter != extension_info_.end()) {
-    extension_info_.erase(iter);
-  } else {
-    // NOTE: This can currently happen if we receive multiple unload
-    // notifications, e.g. setting incognito-enabled state for a
-    // disabled extension (e.g., via sync).  See
-    // http://code.google.com/p/chromium/issues/detail?id=50582 .
-    NOTREACHED() << id;
-  }
-}
-
 bool ChromeURLRequestContext::IsExternal() const {
   return false;
 }
@@ -925,7 +808,6 @@ ChromeURLRequestContext::ChromeURLRequestContext(
   http_auth_handler_factory_ = other->http_auth_handler_factory_;
 
   // Set ChromeURLRequestContext members
-  extension_info_ = other->extension_info_;
   user_script_dir_path_ = other->user_script_dir_path_;
   appcache_service_ = other->appcache_service_;
   database_tracker_ = other->database_tracker_;
@@ -936,6 +818,7 @@ ChromeURLRequestContext::ChromeURLRequestContext(
   is_off_the_record_ = other->is_off_the_record_;
   blob_storage_context_ = other->blob_storage_context_;
   file_system_host_context_ = other->file_system_host_context_;
+  extension_info_map_ = other->extension_info_map_;
 }
 
 void ChromeURLRequestContext::OnAcceptLanguageChange(
@@ -993,25 +876,6 @@ ChromeURLRequestContextFactory::ChromeURLRequestContextFactory(Profile* profile)
   host_zoom_map_ = profile->GetHostZoomMap();
   transport_security_state_ = profile->GetTransportSecurityState();
 
-  if (profile->GetExtensionsService()) {
-    const ExtensionList* extensions =
-        profile->GetExtensionsService()->extensions();
-    for (ExtensionList::const_iterator iter = extensions->begin();
-        iter != extensions->end(); ++iter) {
-      extension_info_[(*iter)->id()] =
-          linked_ptr<ChromeURLRequestContext::ExtensionInfo>(
-              new ChromeURLRequestContext::ExtensionInfo(
-                  (*iter)->name(),
-                  (*iter)->path(),
-                  (*iter)->default_locale(),
-                  (*iter)->incognito_split_mode(),
-                  (*iter)->web_extent(),
-                  (*iter)->GetEffectiveHostPermissions(),
-                  (*iter)->api_permissions(),
-                  (*iter)->icons()));
-    }
-  }
-
   if (profile->GetUserScriptMaster())
     user_script_dir_path_ = profile->GetUserScriptMaster()->user_script_dir();
 
@@ -1022,6 +886,7 @@ ChromeURLRequestContextFactory::ChromeURLRequestContextFactory(Profile* profile)
   database_tracker_ = profile->GetDatabaseTracker();
   blob_storage_context_ = profile->GetBlobStorageContext();
   file_system_host_context_ = profile->GetFileSystemHostContext();
+  extension_info_map_ = profile->GetExtensionInfoMap();
 }
 
 ChromeURLRequestContextFactory::~ChromeURLRequestContextFactory() {
@@ -1037,7 +902,6 @@ void ChromeURLRequestContextFactory::ApplyProfileParametersToContext(
   context->set_accept_language(accept_language_);
   context->set_accept_charset(accept_charset_);
   context->set_referrer_charset(referrer_charset_);
-  context->set_extension_info(extension_info_);
   context->set_user_script_dir_path(user_script_dir_path_);
   context->set_host_content_settings_map(host_content_settings_map_);
   context->set_host_zoom_map(host_zoom_map_);
@@ -1048,6 +912,7 @@ void ChromeURLRequestContextFactory::ApplyProfileParametersToContext(
   context->set_database_tracker(database_tracker_);
   context->set_blob_storage_context(blob_storage_context_);
   context->set_file_system_host_context(file_system_host_context_);
+  context->set_extension_info_map(extension_info_map_);
 }
 
 // ----------------------------------------------------------------------------
diff --git a/chrome/browser/net/chrome_url_request_context.h b/chrome/browser/net/chrome_url_request_context.h
index 3141364..eccf823 100644
--- a/chrome/browser/net/chrome_url_request_context.h
+++ b/chrome/browser/net/chrome_url_request_context.h
@@ -6,14 +6,13 @@
 #define CHROME_BROWSER_NET_CHROME_URL_REQUEST_CONTEXT_H_
 #pragma once
 
-#include <map>
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
-#include "base/linked_ptr.h"
 #include "chrome/browser/appcache/chrome_appcache_service.h"
 #include "chrome/browser/chrome_blob_storage_context.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/file_system/file_system_host_context.h"
 #include "chrome/browser/host_content_settings_map.h"
 #include "chrome/browser/host_zoom_map.h"
@@ -21,7 +20,6 @@
 #include "chrome/browser/net/chrome_cookie_policy.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "chrome/browser/prefs/pref_service.h"
-#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #include "chrome/common/notification_registrar.h"
@@ -49,72 +47,8 @@ class ChromeURLRequestContextFactory;
 // including the constructor and destructor.
 class ChromeURLRequestContext : public URLRequestContext {
  public:
-  // Maintains some extension-related state we need on the IO thread.
-  // TODO(aa): It would be cool if the Extension objects in ExtensionsService
-  // could be immutable and ref-counted so that we could use them directly from
-  // both threads. There is only a small amount of mutable state in Extension.
-  struct ExtensionInfo {
-    ExtensionInfo(const std::string& name,
-                  const FilePath& path,
-                  const std::string& default_locale,
-                  bool incognito_split_mode,
-                  const ExtensionExtent& extent,
-                  const ExtensionExtent& effective_host_permissions,
-                  const std::set<std::string>& api_permissions,
-                  const ExtensionIconSet& icons)
-        : name(name),
-          path(path),
-          default_locale(default_locale),
-          incognito_split_mode(incognito_split_mode),
-          extent(extent),
-          effective_host_permissions(effective_host_permissions),
-          api_permissions(api_permissions),
-          icons(icons) {
-    }
-    const std::string name;
-    const FilePath path;
-    const std::string default_locale;
-    const bool incognito_split_mode;
-    const ExtensionExtent extent;
-    const ExtensionExtent effective_host_permissions;
-    std::set<std::string> api_permissions;
-    ExtensionIconSet icons;
-  };
-
-  // Map of extension info by extension id.
-  typedef std::map<std::string, linked_ptr<ExtensionInfo> > ExtensionInfoMap;
-
   ChromeURLRequestContext();
 
-  // Gets the name for the specified extension.
-  std::string GetNameForExtension(const std::string& id);
-
-  // Gets the path to the directory for the specified extension.
-  FilePath GetPathForExtension(const std::string& id);
-
-  // Returns true if the specified extension exists and has a non-empty web
-  // extent.
-  bool ExtensionHasWebExtent(const std::string& id);
-
-  // Returns true if the specified extension exists and can load in incognito
-  // contexts.
-  bool ExtensionCanLoadInIncognito(const std::string& id);
-
-  // Returns an empty string if the extension with |id| doesn't have a default
-  // locale.
-  std::string GetDefaultLocaleForExtension(const std::string& id);
-
-  // Gets the effective host permissions for the extension with |id|.
-  ExtensionExtent
-      GetEffectiveHostPermissionsForExtension(const std::string& id);
-
-  // Determine whether a URL has access to the specified extension permission.
-  bool CheckURLAccessToExtensionPermission(const GURL& url,
-                                           const char* permission_name);
-
-  // Returns true if the specified URL references the icon for an extension.
-  bool URLIsForExtensionIcon(const GURL& url);
-
   // Gets the path to the directory user scripts are stored in.
   FilePath user_script_dir_path() const {
     return user_script_dir_path_;
@@ -156,12 +90,9 @@ class ChromeURLRequestContext : public URLRequestContext {
 
   const HostZoomMap* host_zoom_map() const { return host_zoom_map_; }
 
-  // Callback for when new extensions are loaded. Takes ownership of
-  // |extension_info|.
-  void OnNewExtensions(const std::string& id, ExtensionInfo* extension_info);
-
-  // Callback for when an extension is unloaded.
-  void OnUnloadedExtension(const std::string& id);
+  const ExtensionInfoMap* extension_info_map() const {
+    return extension_info_map_;
+  }
 
   // Returns true if this context is an external request context, like
   // ChromeFrame.
@@ -186,10 +117,6 @@ class ChromeURLRequestContext : public URLRequestContext {
   void set_referrer_charset(const std::string& referrer_charset) {
     referrer_charset_ = referrer_charset;
   }
-  void set_extension_info(
-      const ChromeURLRequestContext::ExtensionInfoMap& info) {
-    extension_info_ = info;
-  }
   void set_transport_security_state(
       net::TransportSecurityState* state) {
     transport_security_state_ = state;
@@ -247,6 +174,9 @@ class ChromeURLRequestContext : public URLRequestContext {
   void set_file_system_host_context(FileSystemHostContext* context) {
     file_system_host_context_ = context;
   }
+  void set_extension_info_map(ExtensionInfoMap* map) {
+    extension_info_map_ = map;
+  }
   void set_net_log(net::NetLog* net_log) {
     net_log_ = net_log;
   }
@@ -262,8 +192,6 @@ class ChromeURLRequestContext : public URLRequestContext {
   void OnDefaultCharsetChange(const std::string& default_charset);
 
  protected:
-  ExtensionInfoMap extension_info_;
-
   // Path to the directory user scripts are stored in.
   FilePath user_script_dir_path_;
 
@@ -274,6 +202,7 @@ class ChromeURLRequestContext : public URLRequestContext {
   scoped_refptr<HostZoomMap> host_zoom_map_;
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   scoped_refptr<FileSystemHostContext> file_system_host_context_;
+  scoped_refptr<ExtensionInfoMap> extension_info_map_;
 
   bool is_media_;
   bool is_off_the_record_;
@@ -347,13 +276,6 @@ class ChromeURLRequestContextGetter : public URLRequestContextGetter,
   // thread before the instance is deleted on the IO thread.
   void CleanupOnUIThread();
 
-  // These methods simply forward to the corresponding methods on
-  // ChromeURLRequestContext. Takes ownership of |extension_info|.
-  void OnNewExtensions(
-      const std::string& extension_id,
-      ChromeURLRequestContext::ExtensionInfo* extension_info);
-  void OnUnloadedExtension(const std::string& id);
-
   // NotificationObserver implementation.
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
@@ -429,7 +351,7 @@ class ChromeURLRequestContextFactory {
   std::string accept_language_;
   std::string accept_charset_;
   std::string referrer_charset_;
-  ChromeURLRequestContext::ExtensionInfoMap extension_info_;
+
   // TODO(aa): I think this can go away now as we no longer support standalone
   // user scripts.
   FilePath user_script_dir_path_;
@@ -442,6 +364,7 @@ class ChromeURLRequestContextFactory {
   scoped_refptr<net::CookieMonster::Delegate> cookie_monster_delegate_;
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   scoped_refptr<FileSystemHostContext> file_system_host_context_;
+  scoped_refptr<ExtensionInfoMap> extension_info_map_;
 
   FilePath profile_dir_path_;
 
diff --git a/chrome/browser/profile.cc b/chrome/browser/profile.cc
index 36fabbd..eb7157d 100644
--- a/chrome/browser/profile.cc
+++ b/chrome/browser/profile.cc
@@ -560,6 +560,10 @@ class OffTheRecordProfileImpl : public Profile,
     return blob_storage_context_;
   }
 
+  virtual ExtensionInfoMap* GetExtensionInfoMap() {
+    return profile_->GetExtensionInfoMap();
+  }
+
  private:
   NotificationRegistrar registrar_;
 
diff --git a/chrome/browser/profile.h b/chrome/browser/profile.h
index bbd710c..3ef99bf 100644
--- a/chrome/browser/profile.h
+++ b/chrome/browser/profile.h
@@ -42,6 +42,7 @@ class BrowserThemeProvider;
 class ChromeAppCacheService;
 class ChromeBlobStorageContext;
 class ChromeURLRequestContextGetter;
+class CloudPrintProxyService;
 class DesktopNotificationService;
 class DownloadManager;
 class Extension;
@@ -64,6 +65,7 @@ class PasswordStore;
 class PersonalDataManager;
 class PinnedTabService;
 class PrefService;
+class ExtensionInfoMap;
 class ProfileSyncService;
 class ProfileSyncFactory;
 class SessionService;
@@ -86,7 +88,6 @@ class VisitedLinkEventListener;
 class WebDataService;
 class WebKitContext;
 class WebResourceService;
-class CloudPrintProxyService;
 
 typedef intptr_t ProfileId;
 
@@ -446,6 +447,9 @@ class Profile {
   // profile.
   virtual ChromeBlobStorageContext* GetBlobStorageContext() = 0;
 
+  // Returns the IO-thread-accessible profile data for this profile.
+  virtual ExtensionInfoMap* GetExtensionInfoMap() = 0;
+
 #if defined(OS_CHROMEOS)
   // Returns ChromeOS's ProxyConfigServiceImpl, creating if not yet created.
   virtual chromeos::ProxyConfigServiceImpl*
diff --git a/chrome/browser/profile_impl.cc b/chrome/browser/profile_impl.cc
index f72a6a5..8e541fb 100644
--- a/chrome/browser/profile_impl.cc
+++ b/chrome/browser/profile_impl.cc
@@ -28,6 +28,7 @@
 #include "chrome/browser/download/download_manager.h"
 #include "chrome/browser/extensions/extension_devtools_manager.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
+#include "chrome/browser/extensions/extension_info_map.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extensions_service.h"
@@ -165,38 +166,6 @@ bool HasACacheSubdir(const FilePath &dir) {
          file_util::PathExists(GetMediaCachePath(dir));
 }
 
-void PostExtensionLoadedToContextGetter(ChromeURLRequestContextGetter* getter,
-                                        Extension* extension) {
-  if (!getter)
-    return;
-  // Callee takes ownership of new ExtensionInfo struct.
-  ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(getter,
-                        &ChromeURLRequestContextGetter::OnNewExtensions,
-                        extension->id(),
-                        new ChromeURLRequestContext::ExtensionInfo(
-                        extension->name(),
-                        extension->path(),
-                        extension->default_locale(),
-                        extension->incognito_split_mode(),
-                        extension->web_extent(),
-                        extension->GetEffectiveHostPermissions(),
-                        extension->api_permissions(),
-                        extension->icons())));
-}
-
-void PostExtensionUnloadedToContextGetter(ChromeURLRequestContextGetter* getter,
-                                          Extension* extension) {
-  if (!getter)
-    return;
-  ChromeThread::PostTask(
-      ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(getter,
-                        &ChromeURLRequestContextGetter::OnUnloadedExtension,
-                        extension->id()));
-}
-
 // Returns true if the default apps should be loaded (so that the app panel is
 // not empty).
 bool IncludeDefaultApps() {
@@ -363,6 +332,8 @@ ProfileImpl::ProfileImpl(const FilePath& path)
   background_contents_service_.reset(
       new BackgroundContentsService(this, CommandLine::ForCurrentProcess()));
 
+  extension_info_map_ = new ExtensionInfoMap();
+
   // Log the profile size after a reasonable startup delay.
   ChromeThread::PostDelayedTask(ChromeThread::FILE, FROM_HERE,
                                 new ProfileSizeTask(path_), 112000);
@@ -767,65 +738,23 @@ URLRequestContextGetter* ProfileImpl::GetRequestContextForExtensions() {
   return extensions_request_context_;
 }
 
-// TODO(mpcomplete): This is lame. 5+ copies of the extension data on the IO
-// thread. We should have 1 shared data object that all the contexts get access
-// to. Fix by M8.
-void ProfileImpl::RegisterExtensionWithRequestContexts(
-    Extension* extension) {
-  // Notify the default, extension and media contexts on the IO thread.
-  PostExtensionLoadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(GetRequestContext()),
-                                                  extension);
-  PostExtensionLoadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(
-          GetRequestContextForExtensions()),
-      extension);
-  PostExtensionLoadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(
-          GetRequestContextForMedia()),
-      extension);
-
-  // Ditto for OTR if it's active, except for the media context which is the
-  // same as the regular context.
-  if (off_the_record_profile_.get()) {
-    PostExtensionLoadedToContextGetter(
-        static_cast<ChromeURLRequestContextGetter*>(
-            off_the_record_profile_->GetRequestContext()),
-        extension);
-    PostExtensionLoadedToContextGetter(
-        static_cast<ChromeURLRequestContextGetter*>(
-            off_the_record_profile_->GetRequestContextForExtensions()),
-        extension);
-  }
+void ProfileImpl::RegisterExtensionWithRequestContexts(Extension* extension) {
+  // AddRef to ensure the data lives until the other thread gets it. Balanced in
+  // OnNewExtensions.
+  extension->static_data()->AddRef();
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(extension_info_map_.get(),
+                        &ExtensionInfoMap::AddExtension,
+                        extension->static_data()));
 }
 
-void ProfileImpl::UnregisterExtensionWithRequestContexts(
-    Extension* extension) {
-  // Notify the default, extension and media contexts on the IO thread.
-  PostExtensionUnloadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(GetRequestContext()),
-                                                  extension);
-  PostExtensionUnloadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(
-          GetRequestContextForExtensions()),
-      extension);
-  PostExtensionUnloadedToContextGetter(
-      static_cast<ChromeURLRequestContextGetter*>(
-          GetRequestContextForMedia()),
-      extension);
-
-  // Ditto for OTR if it's active, except for the media context which is the
-  // same as the regular context.
-  if (off_the_record_profile_.get()) {
-    PostExtensionUnloadedToContextGetter(
-        static_cast<ChromeURLRequestContextGetter*>(
-            off_the_record_profile_->GetRequestContext()),
-        extension);
-    PostExtensionUnloadedToContextGetter(
-        static_cast<ChromeURLRequestContextGetter*>(
-            off_the_record_profile_->GetRequestContextForExtensions()),
-        extension);
-  }
+void ProfileImpl::UnregisterExtensionWithRequestContexts(Extension* extension) {
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(extension_info_map_.get(),
+                        &ExtensionInfoMap::RemoveExtension,
+                        extension->id()));
 }
 
 net::SSLConfigService* ProfileImpl::GetSSLConfigService() {
@@ -1310,6 +1239,10 @@ ChromeBlobStorageContext* ProfileImpl::GetBlobStorageContext() {
   return blob_storage_context_;
 }
 
+ExtensionInfoMap* ProfileImpl::GetExtensionInfoMap() {
+  return extension_info_map_.get();
+}
+
 #if defined(OS_CHROMEOS)
 chromeos::ProxyConfigServiceImpl*
     ProfileImpl::GetChromeOSProxyConfigServiceImpl() {
diff --git a/chrome/browser/profile_impl.h b/chrome/browser/profile_impl.h
index f324fbd..0bf1b56 100644
--- a/chrome/browser/profile_impl.h
+++ b/chrome/browser/profile_impl.h
@@ -111,6 +111,7 @@ class ProfileImpl : public Profile,
   virtual CloudPrintProxyService* GetCloudPrintProxyService();
   void InitCloudPrintProxyService();
   virtual ChromeBlobStorageContext* GetBlobStorageContext();
+  virtual ExtensionInfoMap* GetExtensionInfoMap();
 
 #if defined(OS_CHROMEOS)
   virtual chromeos::ProxyConfigServiceImpl* GetChromeOSProxyConfigServiceImpl();
@@ -245,6 +246,8 @@ class ProfileImpl : public Profile,
 
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
 
+  scoped_refptr<ExtensionInfoMap> extension_info_map_;
+
 #if defined(OS_CHROMEOS)
   scoped_ptr<chromeos::Preferences> chromeos_preferences_;
 
diff --git a/chrome/browser/renderer_host/resource_message_filter.cc b/chrome/browser/renderer_host/resource_message_filter.cc
index 1bfe307..272fc55 100644
--- a/chrome/browser/renderer_host/resource_message_filter.cc
+++ b/chrome/browser/renderer_host/resource_message_filter.cc
@@ -986,8 +986,8 @@ void ResourceMessageFilter::OnCheckNotificationPermission(
   *result = WebKit::WebNotificationPresenter::PermissionNotAllowed;
 
   ChromeURLRequestContext* context = GetRequestContextForURL(source_url);
-  if (context->CheckURLAccessToExtensionPermission(source_url,
-      Extension::kNotificationPermission)) {
+  if (context->extension_info_map()->CheckURLAccessToExtensionPermission(
+          source_url, Extension::kNotificationPermission)) {
     *result = WebKit::WebNotificationPresenter::PermissionAllowed;
     return;
   }
@@ -1653,9 +1653,10 @@ void ResourceMessageFilter::OnGetExtensionMessageBundle(
   ChromeURLRequestContext* context = static_cast<ChromeURLRequestContext*>(
     request_context_->GetURLRequestContext());
 
-  FilePath extension_path = context->GetPathForExtension(extension_id);
+  FilePath extension_path =
+      context->extension_info_map()->GetPathForExtension(extension_id);
   std::string default_locale =
-    context->GetDefaultLocaleForExtension(extension_id);
+      context->extension_info_map()->GetDefaultLocaleForExtension(extension_id);
 
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
diff --git a/chrome/browser/worker_host/worker_process_host.cc b/chrome/browser/worker_host/worker_process_host.cc
index 868ba6c..1c2efd3 100644
--- a/chrome/browser/worker_host/worker_process_host.cc
+++ b/chrome/browser/worker_host/worker_process_host.cc
@@ -414,7 +414,7 @@ void WorkerProcessHost::UpdateTitle() {
     // the name of the extension.
     std::string extension_name = static_cast<ChromeURLRequestContext*>(
         Profile::GetDefaultRequestContext()->GetURLRequestContext())->
-        GetNameForExtension(title);
+        extension_info_map()->GetNameForExtension(title);
     if (!extension_name.empty()) {
       titles.insert(extension_name);
       continue;
diff --git a/chrome/chrome_browser.gypi b/chrome/chrome_browser.gypi
index f1b93e1..b28ecb5 100644
--- a/chrome/chrome_browser.gypi
+++ b/chrome/chrome_browser.gypi
@@ -1448,6 +1448,8 @@
         'browser/extensions/extension_idle_api_constants.h',
         'browser/extensions/extension_i18n_api.cc',
         'browser/extensions/extension_i18n_api.h',
+        'browser/extensions/extension_info_map.cc',
+        'browser/extensions/extension_info_map.h',
         'browser/extensions/extension_infobar_module.cc',
         'browser/extensions/extension_infobar_module.h',
         'browser/extensions/extension_infobar_module_constants.cc',
diff --git a/chrome/chrome_tests.gypi b/chrome/chrome_tests.gypi
index 48fc7f4..0b0a9e7 100644
--- a/chrome/chrome_tests.gypi
+++ b/chrome/chrome_tests.gypi
@@ -1068,6 +1068,7 @@
         'browser/encoding_menu_controller_unittest.cc',
         'browser/extensions/convert_user_script_unittest.cc',
         'browser/extensions/extension_icon_manager_unittest.cc',
+        'browser/extensions/extension_info_map_unittest.cc',
         'browser/extensions/extension_menu_manager_unittest.cc',
         'browser/extensions/extension_prefs_unittest.cc',
         'browser/extensions/extension_pref_store_unittest.cc',
diff --git a/chrome/common/extensions/extension.cc b/chrome/common/extensions/extension.cc
index fbfc73d..a9a8fc9 100644
--- a/chrome/common/extensions/extension.cc
+++ b/chrome/common/extensions/extension.cc
@@ -240,6 +240,21 @@ const size_t Extension::kNumHostedAppPermissions =
 // We purposefully don't put this into kPermissionNames.
 const char Extension::kOldUnlimitedStoragePermission[] = "unlimited_storage";
 
+//
+// Extension::StaticData
+//
+
+Extension::StaticData::StaticData()
+    : incognito_split_mode(false) {
+}
+
+Extension::StaticData::~StaticData() {
+}
+
+//
+// Extension
+//
+
 // static
 int Extension::GetPermissionMessageId(const std::string& permission) {
   return PermissionMap::GetSingleton()->GetPermissionMessageId(permission);
@@ -265,8 +280,8 @@ std::vector<string16> Extension::GetPermissionMessages() {
 
 std::set<string16> Extension::GetSimplePermissionMessages() {
   std::set<string16> messages;
-  std::set<std::string>::iterator i;
-  for (i = api_permissions_.begin(); i != api_permissions_.end(); ++i) {
+  std::set<std::string>::const_iterator i;
+  for (i = api_permissions().begin(); i != api_permissions().end(); ++i) {
     int message_id = GetPermissionMessageId(*i);
     if (message_id)
       messages.insert(l10n_util::GetStringUTF16(message_id));
@@ -810,7 +825,7 @@ bool Extension::LoadLaunchURL(const DictionaryValue* manifest,
   }
 
   // If there is no extent, we default the extent based on the launch URL.
-  if (web_extent_.is_empty() && !launch_web_url_.empty()) {
+  if (web_extent().is_empty() && !launch_web_url_.empty()) {
     GURL launch_url(launch_web_url_);
     URLPattern pattern(kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
@@ -819,7 +834,23 @@ bool Extension::LoadLaunchURL(const DictionaryValue* manifest,
     }
     pattern.set_host(launch_url.host());
     pattern.set_path("/*");
-    web_extent_.AddPattern(pattern);
+    mutable_static_data_->extent.AddPattern(pattern);
+  }
+
+  // In order for the --apps-gallery-url switch to work with the gallery
+  // process isolation, we must insert any provided value into the component
+  // app's launch url and web extent.
+  if (id() == extension_misc::kWebStoreAppId) {
+    GURL gallery_url(CommandLine::ForCurrentProcess()->
+        GetSwitchValueASCII(switches::kAppsGalleryURL));
+    if (gallery_url.is_valid()) {
+      launch_web_url_ = gallery_url.spec();
+
+      URLPattern pattern(URLPattern::SCHEME_HTTP | URLPattern::SCHEME_HTTPS);
+      pattern.Parse(gallery_url.spec());
+      pattern.set_path(pattern.path() + '*');
+      mutable_static_data_->extent.AddPattern(pattern);
+    }
   }
 
   return true;
@@ -897,17 +928,18 @@ bool Extension::EnsureNotHybridApp(const DictionaryValue* manifest,
 }
 
 Extension::Extension(const FilePath& path)
-    : converted_from_user_script_(false),
+    : mutable_static_data_(new StaticData),
+      converted_from_user_script_(false),
       is_theme_(false),
       is_app_(false),
       launch_container_(extension_misc::LAUNCH_TAB),
       launch_width_(0),
       launch_height_(0),
-      incognito_split_mode_(true),
       background_page_ready_(false),
       being_upgraded_(false) {
   DCHECK(path.IsAbsolute());
 
+  static_data_ = mutable_static_data_;
   apps_enabled_ = AppsAreEnabled();
   location_ = INVALID;
 
@@ -920,9 +952,9 @@ Extension::Extension(const FilePath& path)
       path_str[1] == ':')
     path_str[0] += ('A' - 'a');
 
-  path_ = FilePath(path_str);
+  mutable_static_data_->path = FilePath(path_str);
 #else
-  path_ = path;
+  mutable_static_data_->path = path;
 #endif
 }
 
@@ -1121,11 +1153,15 @@ bool Extension::AppsAreEnabled() {
 
 bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
                               std::string* error) {
+  // Unit tests reuse Extension objects, so we need to reset mutable_static_data
+  // when we re-initialize.
+  mutable_static_data_ = const_cast<StaticData*>(static_data_.get());
+
   if (source.HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
     if (!source.GetString(keys::kPublicKey, &public_key_) ||
         !ParsePEMKeyBytes(public_key_, &public_key_bytes) ||
-        !GenerateId(public_key_bytes, &id_)) {
+        !GenerateId(public_key_bytes, &mutable_static_data_->id)) {
       *error = errors::kInvalidKey;
       return false;
     }
@@ -1136,7 +1172,8 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
     // If there is a path, we generate the ID from it. This is useful for
     // development mode, because it keeps the ID stable across restarts and
     // reloading the extension.
-    if (!GenerateId(WideToUTF8(path_.ToWStringHack()), &id_)) {
+    if (!GenerateId(WideToUTF8(path().ToWStringHack()),
+                    &mutable_static_data_->id)) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
@@ -1146,7 +1183,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
   manifest_value_.reset(static_cast<DictionaryValue*>(source.DeepCopy()));
 
   // Initialize the URL.
-  extension_url_ = Extension::GetBaseURLFromExtensionId(id_);
+  extension_url_ = Extension::GetBaseURLFromExtensionId(id());
 
   // Initialize version.
   std::string version_str;
@@ -1167,7 +1204,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
     return false;
   }
   base::i18n::AdjustStringForLocaleDirection(localized_name, &localized_name);
-  name_ = UTF16ToUTF8(localized_name);
+  mutable_static_data_->name = UTF16ToUTF8(localized_name);
 
   // Initialize description (if present).
   if (source.HasKey(keys::kDescription)) {
@@ -1263,7 +1300,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
           return false;
         }
 
-        icons_.Add(kIconSizes[i], icon_path);
+        mutable_static_data_->icons.Add(kIconSizes[i], icon_path);
       }
     }
   }
@@ -1376,7 +1413,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* plugin_value;
-      std::string path;
+      std::string path_str;
       bool is_public = false;
 
       if (!list_value->GetDictionary(i, &plugin_value)) {
@@ -1385,7 +1422,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
       }
 
       // Get plugins[i].path.
-      if (!plugin_value->GetString(keys::kPluginsPath, &path)) {
+      if (!plugin_value->GetString(keys::kPluginsPath, &path_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPluginsPath, base::IntToString(i));
         return false;
@@ -1401,7 +1438,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
       }
 
       plugins_.push_back(PluginInfo());
-      plugins_.back().path = path_.AppendASCII(path);
+      plugins_.back().path = path().AppendASCII(path_str);
       plugins_.back().is_public = is_public;
     }
   }
@@ -1541,7 +1578,8 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
 
   // Load App settings.
   if (!LoadIsApp(manifest_value_.get(), error) ||
-      !LoadExtent(manifest_value_.get(), keys::kWebURLs, &web_extent_,
+      !LoadExtent(manifest_value_.get(), keys::kWebURLs,
+                  &mutable_static_data_->extent,
                   errors::kInvalidWebURLs, errors::kInvalidWebURL, error) ||
       !EnsureNotHybridApp(manifest_value_.get(), error) ||
       !LoadLaunchURL(manifest_value_.get(), error) ||
@@ -1614,13 +1652,13 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
       if (web_extent().is_empty() || location() == Extension::COMPONENT) {
         // Check if it's a module permission.  If so, enable that permission.
         if (IsAPIPermission(permission_str)) {
-          api_permissions_.insert(permission_str);
+          mutable_static_data_->api_permissions.insert(permission_str);
           continue;
         }
       } else {
         // Hosted apps only get access to a subset of the valid permissions.
         if (IsHostedAppPermission(permission_str)) {
-          api_permissions_.insert(permission_str);
+          mutable_static_data_->api_permissions.insert(permission_str);
           continue;
         }
       }
@@ -1650,8 +1688,9 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
   }
 
   if (source.HasKey(keys::kDefaultLocale)) {
-    if (!source.GetString(keys::kDefaultLocale, &default_locale_) ||
-        default_locale_.empty()) {
+    if (!source.GetString(keys::kDefaultLocale,
+                          &mutable_static_data_->default_locale) ||
+        mutable_static_data_->default_locale.empty()) {
       *error = errors::kInvalidDefaultLocale;
       return false;
     }
@@ -1720,7 +1759,7 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
 
   // Initialize incognito behavior. Apps default to split mode, extensions
   // default to spanning.
-  incognito_split_mode_ = is_app_;
+  mutable_static_data_->incognito_split_mode = is_app_;
   if (source.HasKey(keys::kIncognito)) {
     std::string value;
     if (!source.GetString(keys::kIncognito, &value)) {
@@ -1728,15 +1767,17 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
       return false;
     }
     if (value == values::kIncognitoSpanning) {
-      incognito_split_mode_ = false;
+      mutable_static_data_->incognito_split_mode = false;
     } else if (value == values::kIncognitoSplit) {
-      incognito_split_mode_ = true;
+      mutable_static_data_->incognito_split_mode = true;
     } else {
       *error = errors::kInvalidIncognitoBehavior;
       return false;
     }
   }
 
+  InitEffectiveHostPermissions();
+
   // Although |source| is passed in as a const, it's still possible to modify
   // it.  This is dangerous since the utility process re-uses |source| after
   // it calls InitFromValue, passing it up to the browser process which calls
@@ -1744,6 +1785,9 @@ bool Extension::InitFromValue(const DictionaryValue& source, bool require_key,
   // accidentally modifies it.
   DCHECK(source.Equals(manifest_value_.get()));
 
+  // Ensure we can't modify our static data anymore.
+  mutable_static_data_ = NULL;
+
   return true;
 }
 
@@ -1762,7 +1806,7 @@ GURL Extension::GalleryUrl() const {
   if (!update_url_.DomainIs("google.com"))
     return GURL();
 
-  GURL url(ChromeStoreURL() + std::string("/detail/") + id_);
+  GURL url(ChromeStoreURL() + std::string("/detail/") + id());
 
   return url;
 }
@@ -1773,8 +1817,8 @@ std::set<FilePath> Extension::GetBrowserImages() {
   // indicate that we're doing something wrong.
 
   // Extension icons.
-  for (ExtensionIconSet::IconMap::const_iterator iter = icons_.map().begin();
-       iter != icons_.map().end(); ++iter) {
+  for (ExtensionIconSet::IconMap::const_iterator iter = icons().map().begin();
+       iter != icons().map().end(); ++iter) {
     image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
   }
 
@@ -1889,14 +1933,14 @@ SkBitmap* Extension::GetCachedImageImpl(const ExtensionResource& source,
 
 ExtensionResource Extension::GetIconResource(
     int size, ExtensionIconSet::MatchType match_type) {
-  std::string path = icons_.Get(size, match_type);
+  std::string path = icons().Get(size, match_type);
   if (path.empty())
     return ExtensionResource();
   return GetResource(path);
 }
 
 GURL Extension::GetIconURL(int size, ExtensionIconSet::MatchType match_type) {
-  std::string path = icons_.Get(size, match_type);
+  std::string path = icons().Get(size, match_type);
   if (path.empty())
     return GURL();
   else
@@ -1958,22 +2002,18 @@ bool Extension::HasHostPermission(const GURL& url) const {
   return false;
 }
 
-const ExtensionExtent Extension::GetEffectiveHostPermissions() const {
-  ExtensionExtent effective_hosts;
-
+void Extension::InitEffectiveHostPermissions() {
   for (URLPatternList::const_iterator host = host_permissions_.begin();
        host != host_permissions_.end(); ++host)
-    effective_hosts.AddPattern(*host);
+    mutable_static_data_->effective_host_permissions.AddPattern(*host);
 
   for (UserScriptList::const_iterator content_script = content_scripts_.begin();
        content_script != content_scripts_.end(); ++content_script) {
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern)
-      effective_hosts.AddPattern(*pattern);
+      mutable_static_data_->effective_host_permissions.AddPattern(*pattern);
   }
-
-  return effective_hosts;
 }
 
 bool Extension::HasEffectiveAccessToAllHosts() const {
diff --git a/chrome/common/extensions/extension.h b/chrome/common/extensions/extension.h
index a28259c..51f35e0 100644
--- a/chrome/common/extensions/extension.h
+++ b/chrome/common/extensions/extension.h
@@ -14,6 +14,7 @@
 #include "base/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/scoped_ptr.h"
+#include "base/ref_counted.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_extent.h"
 #include "chrome/common/extensions/extension_icon_set.h"
@@ -76,6 +77,64 @@ class Extension {
     EXTENSION_ICON_BITTY = 16,
   };
 
+  // Contains a subset of the extension's data that doesn't change once
+  // initialized, and therefore shareable across threads without locking.
+  struct StaticData : public base::RefCountedThreadSafe<StaticData> {
+    StaticData();
+
+    // TODO(mpcomplete): RefCountedThreadSafe does not allow AddRef/Release on
+    // const objects. I think that is a mistake. Until we can fix that, here's
+    // a workaround.
+    void AddRef() const {
+      const_cast<StaticData*>(this)->
+          base::RefCountedThreadSafe<StaticData>::AddRef();
+    }
+    void Release() const {
+      const_cast<StaticData*>(this)->
+          base::RefCountedThreadSafe<StaticData>::Release();
+    }
+
+    // A persistent, globally unique ID. An extension's ID is used in things
+    // like directory structures and URLs, and is expected to not change across
+    // versions. It is generated as a SHA-256 hash of the extension's public
+    // key, or as a hash of the path in the case of unpacked extensions.
+    std::string id;
+
+    // The extension's human-readable name. Name is used for display purpose. It
+    // might be wrapped with unicode bidi control characters so that it is
+    // displayed correctly in RTL context.
+    // NOTE: Name is UTF-8 and may contain non-ascii characters.
+    std::string name;
+
+    // The absolute path to the directory the extension is stored in.
+    FilePath path;
+
+    // Default locale for fall back. Can be empty if extension is not localized.
+    std::string default_locale;
+
+    // If true, a separate process will be used for the extension in incognito
+    // mode.
+    bool incognito_split_mode;
+
+    // Defines the set of URLs in the extension's web content.
+    ExtensionExtent extent;
+
+    // The set of hosts that the extension effectively has access to. This is
+    // used in the permissions UI and is a combination of the hosts accessible
+    // through content scripts and the hosts accessible through XHR.
+    ExtensionExtent effective_host_permissions;
+
+    // The set of module-level APIs this extension can use.
+    std::set<std::string> api_permissions;
+
+    // The icons for the extension.
+    ExtensionIconSet icons;
+
+   protected:
+    friend class base::RefCountedThreadSafe<StaticData>;
+    ~StaticData();
+  };
+
   // A permission is defined by its |name| (what is used in the manifest),
   // and the |message_id| that's used by install/update UI.
   struct Permission {
@@ -256,16 +315,17 @@ class Extension {
   bool InitFromValue(const DictionaryValue& value, bool require_key,
                      std::string* error);
 
-  const FilePath& path() const { return path_; }
-  void set_path(const FilePath& path) { path_ = path; }
+  const StaticData* static_data() const { return static_data_; }
+
+  const FilePath& path() const { return static_data_->path; }
   const GURL& url() const { return extension_url_; }
   Location location() const { return location_; }
   void set_location(Location location) { location_ = location; }
-  const std::string& id() const { return id_; }
+  const std::string& id() const { return static_data_->id; }
   const Version* version() const { return version_.get(); }
   // String representation of the version number.
   const std::string VersionString() const;
-  const std::string& name() const { return name_; }
+  const std::string& name() const { return static_data_->name; }
   const std::string& public_key() const { return public_key_; }
   const std::string& description() const { return description_; }
   bool converted_from_user_script() const {
@@ -280,7 +340,7 @@ class Extension {
   const GURL& devtools_url() const { return devtools_url_; }
   const std::vector<GURL>& toolstrips() const { return toolstrips_; }
   const std::set<std::string>& api_permissions() const {
-    return api_permissions_;
+    return static_data_->api_permissions;
   }
   const URLPatternList& host_permissions() const {
     return host_permissions_;
@@ -294,10 +354,9 @@ class Extension {
     return HasApiPermission(this->api_permissions(), function_name);
   }
 
-  // Returns the set of hosts that the extension effectively has access to. This
-  // is used in the permissions UI and is a combination of the hosts accessible
-  // through content scripts and the hosts accessible through XHR.
-  const ExtensionExtent GetEffectiveHostPermissions() const;
+  const ExtensionExtent& GetEffectiveHostPermissions() const {
+    return static_data_->effective_host_permissions;
+  }
 
   // Whether or not the extension is allowed permission for a URL pattern from
   // the manifest.  http, https, and chrome://favicon/ is allowed for all
@@ -317,7 +376,7 @@ class Extension {
 
   const GURL& update_url() const { return update_url_; }
 
-  const ExtensionIconSet& icons() const { return icons_; }
+  const ExtensionIconSet& icons() const { return static_data_->icons; }
 
   // Returns the Google Gallery URL for this extension, if one exists. For
   // third-party extensions, this returns a blank GURL.
@@ -345,7 +404,9 @@ class Extension {
     return manifest_value_.get();
   }
 
-  const std::string default_locale() const { return default_locale_; }
+  const std::string default_locale() const {
+    return static_data_->default_locale;
+  }
 
   // Chrome URL overrides (see ExtensionOverrideUI).
   const URLOverrideMap& GetChromeURLOverrides() const {
@@ -355,7 +416,7 @@ class Extension {
   const std::string omnibox_keyword() const { return omnibox_keyword_; }
 
   bool is_app() const { return is_app_; }
-  ExtensionExtent& web_extent() { return web_extent_; }
+  const ExtensionExtent& web_extent() const { return static_data_->extent; }
   const std::string& launch_local_path() const { return launch_local_path_; }
   const std::string& launch_web_url() const { return launch_web_url_; }
   void set_launch_web_url(const std::string& launch_web_url) {
@@ -366,7 +427,9 @@ class Extension {
   }
   int launch_width() const { return launch_width_; }
   int launch_height() const { return launch_height_; }
-  bool incognito_split_mode() const { return incognito_split_mode_; }
+  bool incognito_split_mode() const {
+    return static_data_->incognito_split_mode;
+  }
 
   // Gets the fully resolved absolute launch URL.
   GURL GetFullLaunchURL() const;
@@ -396,8 +459,9 @@ class Extension {
                       const gfx::Size& max_size);
   SkBitmap GetCachedImage(const ExtensionResource& source,
                           const gfx::Size& max_size);
-  bool is_hosted_app() const { return is_app() && !web_extent_.is_empty(); }
-  bool is_packaged_app() const { return is_app() && web_extent_.is_empty(); }
+  bool is_hosted_app() const { return is_app() && !web_extent().is_empty(); }
+  bool is_packaged_app() const { return is_app() && web_extent().is_empty(); }
+
  private:
   // We keep a cache of images loaded from extension resources based on their
   // path and a string representation of a size that may have been used to
@@ -441,6 +505,10 @@ class Extension {
   ExtensionAction* LoadExtensionActionHelper(
       const DictionaryValue* extension_action, std::string* error);
 
+  // Calculates the effective host permissions from the permissions and content
+  // script petterns.
+  void InitEffectiveHostPermissions();
+
   // Figures out if a source contains keys not associated with themes - we
   // don't want to allow scripts and such to be bundled with themes.
   bool ContainsNonThemeKeys(const DictionaryValue& source);
@@ -459,8 +527,12 @@ class Extension {
   // this extension.
   string16 GetHostPermissionMessage();
 
-  // The absolute path to the directory the extension is stored in.
-  FilePath path_;
+  // Collection of extension data that doesn't change doesn't change once an
+  // Extension object has been initialized. The mutable version is valid only
+  // until InitFromValue finishes, to ensure we don't accidentally modify it
+  // post-initialization.
+  StaticData* mutable_static_data_;
+  scoped_refptr<const StaticData> static_data_;
 
   // The base extension url for the extension.
   GURL extension_url_;
@@ -468,23 +540,9 @@ class Extension {
   // The location the extension was loaded from.
   Location location_;
 
-  // A human-readable ID for the extension. The convention is to use something
-  // like 'com.example.myextension', but this is not currently enforced. An
-  // extension's ID is used in things like directory structures and URLs, and
-  // is expected to not change across versions. In the case of conflicts,
-  // updates will only be allowed if the extension can be validated using the
-  // previous version's update key.
-  std::string id_;
-
   // The extension's version.
   scoped_ptr<Version> version_;
 
-  // The extension's human-readable name. Name is used for display purpose. It
-  // might be wrapped with unicode bidi control characters so that it is
-  // displayed correctly in RTL context.
-  // NOTE: Name is UTF-8 and may contain non-ascii characters.
-  std::string name_;
-
   // An optional longer description of the extension.
   std::string description_;
 
@@ -536,24 +594,15 @@ class Extension {
   // Whether the extension is a theme - if it is, certain things are disabled.
   bool is_theme_;
 
-  // The set of module-level APIs this extension can use.
-  std::set<std::string> api_permissions_;
-
   // The sites this extension has permission to talk to (using XHR, etc).
   URLPatternList host_permissions_;
 
-  // The icons for the extension.
-  ExtensionIconSet icons_;
-
   // URL for fetching an update manifest
   GURL update_url_;
 
   // A copy of the manifest that this extension was created from.
   scoped_ptr<DictionaryValue> manifest_value_;
 
-  // Default locale for fall back. Can be empty if extension is not localized.
-  std::string default_locale_;
-
   // A map of chrome:// hostnames (newtab, downloads, etc.) to Extension URLs
   // which override the handling of those URLs.
   URLOverrideMap chrome_url_overrides_;
@@ -565,9 +614,6 @@ class Extension {
   // Whether this extension uses app features.
   bool is_app_;
 
-  // Defines the set of URLs in the extension's web content.
-  ExtensionExtent web_extent_;
-
   // The local path inside the extension to use with the launcher.
   std::string launch_local_path_;
 
@@ -589,10 +635,6 @@ class Extension {
   // The omnibox keyword for this extension, or empty if there is none.
   std::string omnibox_keyword_;
 
-  // If true, a separate process will be used for the extension in incognito
-  // mode.
-  bool incognito_split_mode_;
-
   // Runtime data:
 
   // True if the background page is ready.
diff --git a/chrome/common/extensions/extension_unittest.cc b/chrome/common/extensions/extension_unittest.cc
index aceca8e..0c31199 100644
--- a/chrome/common/extensions/extension_unittest.cc
+++ b/chrome/common/extensions/extension_unittest.cc
@@ -742,13 +742,15 @@ static Extension* LoadManifest(const std::string& dir,
   }
 
   scoped_ptr<Extension> extension(new Extension(path.DirName()));
-  extension->InitFromValue(*static_cast<DictionaryValue*>(result.get()),
-                           false, &error);
+  EXPECT_TRUE(extension->InitFromValue(
+      *static_cast<DictionaryValue*>(result.get()), false, &error)) << error;
 
   return extension.release();
 }
 
-TEST(ExtensionTest, EffectiveHostPermissions) {
+// TODO(erikkay): reenable this test once we actually merge overlapping host
+// permissions together.
+TEST(ExtensionTest, FAILS_EffectiveHostPermissions) {
   scoped_ptr<Extension> extension;
   ExtensionExtent hosts;
 
diff --git a/chrome/test/data/extensions/effective_host_permissions/duplicate_content_script.json b/chrome/test/data/extensions/effective_host_permissions/duplicate_content_script.json
index 584bb59..3da0e9f 100644
--- a/chrome/test/data/extensions/effective_host_permissions/duplicate_content_script.json
+++ b/chrome/test/data/extensions/effective_host_permissions/duplicate_content_script.json
@@ -3,8 +3,8 @@
   "version": "1.0",
   "permissions": [
     "http://*.google.com/",
-    "http://google.com",
-    "https://google.com"
+    "http://google.com/",
+    "https://google.com/"
   ],
   "content_scripts": [
     {
diff --git a/chrome/test/data/extensions/effective_host_permissions/duplicate_host.json b/chrome/test/data/extensions/effective_host_permissions/duplicate_host.json
index c4ea798..1be3912 100644
--- a/chrome/test/data/extensions/effective_host_permissions/duplicate_host.json
+++ b/chrome/test/data/extensions/effective_host_permissions/duplicate_host.json
@@ -3,6 +3,6 @@
   "version": "1.0",
   "permissions": [
     "http://*.google.com/",
-    "http://google.com"
+    "http://google.com/"
   ]
 }
diff --git a/chrome/test/data/extensions/effective_host_permissions/https_not_considered.json b/chrome/test/data/extensions/effective_host_permissions/https_not_considered.json
index 1b3e123..84a414b 100644
--- a/chrome/test/data/extensions/effective_host_permissions/https_not_considered.json
+++ b/chrome/test/data/extensions/effective_host_permissions/https_not_considered.json
@@ -3,7 +3,7 @@
   "version": "1.0",
   "permissions": [
     "http://*.google.com/",
-    "http://google.com",
-    "https://google.com"
+    "http://google.com/",
+    "https://google.com/"
   ]
 }
diff --git a/chrome/test/data/extensions/effective_host_permissions/two_content_scripts.json b/chrome/test/data/extensions/effective_host_permissions/two_content_scripts.json
index 2f7c3df..4c5d4af 100644
--- a/chrome/test/data/extensions/effective_host_permissions/two_content_scripts.json
+++ b/chrome/test/data/extensions/effective_host_permissions/two_content_scripts.json
@@ -3,8 +3,8 @@
   "version": "1.0",
   "permissions": [
     "http://*.google.com/",
-    "http://google.com",
-    "https://google.com"
+    "http://google.com/",
+    "https://google.com/"
   ],
   "content_scripts": [
     {
diff --git a/chrome/test/data/extensions/manifest_tests/tabs_extension.json b/chrome/test/data/extensions/manifest_tests/tabs_extension.json
new file mode 100644
index 0000000..252b41e
--- /dev/null
+++ b/chrome/test/data/extensions/manifest_tests/tabs_extension.json
@@ -0,0 +1,5 @@
+{
+  "name": "test",
+  "version": "0.1",
+  "permissions": ["tabs"]
+}
diff --git a/chrome/test/testing_profile.h b/chrome/test/testing_profile.h
index b1e466d..d84079f 100644
--- a/chrome/test/testing_profile.h
+++ b/chrome/test/testing_profile.h
@@ -269,10 +269,8 @@ class TestingProfile : public Profile {
   virtual ProfileSyncService* GetProfileSyncService(
       const std::string& cros_notes);
   virtual CloudPrintProxyService* GetCloudPrintProxyService() { return NULL; }
-
-  virtual ChromeBlobStorageContext* GetBlobStorageContext() {
-    return NULL;
-  }
+  virtual ChromeBlobStorageContext* GetBlobStorageContext() { return NULL; }
+  virtual ExtensionInfoMap* GetExtensionInfoMap() { return NULL; }
 
  protected:
   base::Time start_time_;