Move BrowserAction out of Extension

chrome/common/extensions/extension.cc

 // 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.
 
 #include "chrome/common/extensions/extension.h"
 
 #include <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 938 matching lines @@
 
   if (page_action_info() && !page_action_info()->default_icon.empty()) {
     for (ExtensionIconSet::IconMap::const_iterator iter =
              page_action_info()->default_icon.map().begin();
          iter != page_action_info()->default_icon.map().end();
          ++iter) {
        image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
     }
   }
 
-  if (browser_action_info() && !browser_action_info()->default_icon.empty()) {
+  const ActionInfo* browser_action = ActionInfoData::GetBrowserActionInfo(this);
+  if (browser_action && !browser_action->default_icon.empty()) {
     for (ExtensionIconSet::IconMap::const_iterator iter =
-             browser_action_info()->default_icon.map().begin();
-         iter != browser_action_info()->default_icon.map().end();
+             browser_action->default_icon.map().begin();
+         iter != browser_action->default_icon.map().end();
          ++iter) {
        image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(iter->second)));
     }
   }
 
   return image_paths;
 }
 
 ExtensionResource Extension::GetIconResource(
     int size, ExtensionIconSet::MatchType match_type) const {
@@ skipping 284 matching lines @@
   runtime_data_.UpdateTabSpecificPermissions(tab_id, permissions);
 }
 
 void Extension::ClearTabSpecificPermissions(int tab_id) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   runtime_data_.ClearTabSpecificPermissions(tab_id);
 }
 
 Extension::ManifestData* Extension::GetManifestData(const std::string& key)
     const {
-  DCHECK(finished_parsing_manifest_);
+  DCHECK(finished_parsing_manifest_ || thread_checker_.CalledOnValidThread());
   ManifestDataMap::const_iterator iter = manifest_data_.find(key);
   if (iter != manifest_data_.end())
     return iter->second.get();
   return NULL;
 }
 
 void Extension::SetManifestData(const std::string& key,
                                 Extension::ManifestData* data) {
-  DCHECK(!finished_parsing_manifest_);
+  DCHECK(!finished_parsing_manifest_ && thread_checker_.CalledOnValidThread());
   manifest_data_[key] = linked_ptr<ManifestData>(data);
 }
 
 Extension::Location Extension::location() const {
   return manifest_->location();
 }
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
@@ skipping 1474 matching lines @@
                                       string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadManifestHandlerFeatures(error) ||
       !LoadDevToolsPage(error) ||
       !LoadInputComponents(*api_permissions, error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
-      !LoadBrowserAction(error) ||
       !LoadSystemIndicator(api_permissions, error) ||
       !LoadChromeURLOverrides(error) ||
       !LoadTextToSpeechVoices(error) ||
       !LoadIncognitoMode(error) ||
       !LoadFileHandlers(error) ||
       !LoadContentSecurityPolicy(error))
     return false;
 
   return true;
 }
@@ skipping 222 matching lines @@
   if (page_action_value) {
     page_action_info_ = LoadExtensionActionInfoHelper(
         this, page_action_value, error);
     if (!page_action_info_.get())
       return false;  // Failed to parse page action definition.
   }
 
   return true;
 }
 
-bool Extension::LoadBrowserAction(string16* error) {
-  if (!manifest_->HasKey(keys::kBrowserAction))
-    return true;
-  DictionaryValue* browser_action_value = NULL;
-  if (!manifest_->GetDictionary(keys::kBrowserAction, &browser_action_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidBrowserAction);
-    return false;
-  }
-
-  browser_action_info_ = LoadExtensionActionInfoHelper(
-      this, browser_action_value, error);
-  if (!browser_action_info_.get())
-    return false;  // Failed to parse browser action definition.
-  return true;
-}
-
 bool Extension::LoadSystemIndicator(APIPermissionSet* api_permissions,
                                     string16* error) {
   if (!manifest_->HasKey(keys::kSystemIndicator)) {
     // There was no manifest entry for the system indicator.
     return true;
   }
 
   DictionaryValue* system_indicator_value = NULL;
   if (!manifest_->GetDictionary(keys::kSystemIndicator,
                                 &system_indicator_value)) {
@@ skipping 612 matching lines @@
 
   return true;
 }
 
 bool Extension::HasMultipleUISurfaces() const {
   int num_surfaces = 0;
 
   if (page_action_info())
     ++num_surfaces;
 
-  if (browser_action_info())
+  if (ActionInfoData::GetBrowserActionInfo(this))
     ++num_surfaces;
 
   if (is_app())
     ++num_surfaces;
 
   return num_surfaces > 1;
 }
 
 void Extension::OverrideLaunchUrl(const GURL& override_url) {
   GURL new_url(override_url);
@@ skipping 164 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions