Move ExtensionAction from common/ to browser/.

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"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/csp_validator.h"
-#include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/features/simple_feature_provider.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
@@ skipping 240 matching lines @@
 }
 
 Extension::InputComponentInfo::~InputComponentInfo() {}
 
 Extension::TtsVoice::TtsVoice() {}
 Extension::TtsVoice::~TtsVoice() {}
 
 Extension::OAuth2Info::OAuth2Info() {}
 Extension::OAuth2Info::~OAuth2Info() {}
 
+Extension::ActionInfo::ActionInfo(Type action_type)
+    : action_type(action_type) {}
+Extension::ActionInfo::~ActionInfo() {}
+
 //
 // Extension
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
                                            Location location,
                                            const DictionaryValue& value,
                                            int flags,
                                            std::string* utf8_error) {
@@ skipping 489 matching lines @@
           base::IntToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
-scoped_ptr<ExtensionAction> Extension::LoadExtensionActionHelper(
+scoped_ptr<Extension::ActionInfo> Extension::LoadExtensionActionHelper(
     const DictionaryValue* extension_action,
-    ExtensionAction::Type action_type,
+    ActionInfo::Type action_type,
     string16* error) {
-  scoped_ptr<ExtensionAction> result(new ExtensionAction(id(), action_type));
-
-  // Page/script actions are hidden/disabled by default, and browser actions are
-  // visible/enabled by default.
-  result->SetAppearance(ExtensionAction::kDefaultTabId,
-                        action_type == ExtensionAction::TYPE_BROWSER ?
-                        ExtensionAction::ACTIVE : ExtensionAction::INVISIBLE);
+  scoped_ptr<ActionInfo> result(new ActionInfo(action_type));
 
   if (manifest_version_ == 1) {
     const ListValue* icons = NULL;
     if (extension_action->HasKey(keys::kPageActionIcons) &&
         extension_action->GetList(keys::kPageActionIcons, &icons)) {
       for (ListValue::const_iterator iter = icons->begin();
            iter != icons->end(); ++iter) {
         std::string path;
         if (!(*iter)->GetAsString(&path) || path.empty()) {
           *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
-          return scoped_ptr<ExtensionAction>();
+          return scoped_ptr<ActionInfo>();
         }
 
-        result->icon_paths()->push_back(path);
+        result->default_icon_path = path;
+        break;
       }
     }
 
     std::string id;
     if (extension_action->HasKey(keys::kPageActionId)) {
       if (!extension_action->GetString(keys::kPageActionId, &id)) {
         *error = ASCIIToUTF16(errors::kInvalidPageActionId);
-        return scoped_ptr<ExtensionAction>();
+        return scoped_ptr<ActionInfo>();
       }
-      result->set_id(id);
+      result->id = id;
     }
   }
 
   std::string default_icon;
   // Read the page action |default_icon| (optional).
   if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
     if (!extension_action->GetString(keys::kPageActionDefaultIcon,
                                      &default_icon) ||
         default_icon.empty()) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
-      return scoped_ptr<ExtensionAction>();
+      return scoped_ptr<ActionInfo>();
     }
-    result->set_default_icon_path(default_icon);
+    result->default_icon_path = default_icon;
   }
 
   // Read the page action title from |default_title| if present, |name| if not
   // (both optional).
   std::string title;
   if (extension_action->HasKey(keys::kPageActionDefaultTitle)) {
     if (!extension_action->GetString(keys::kPageActionDefaultTitle, &title)) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
-      return scoped_ptr<ExtensionAction>();
+      return scoped_ptr<ActionInfo>();
     }
   } else if (manifest_version_ == 1 && extension_action->HasKey(keys::kName)) {
     if (!extension_action->GetString(keys::kName, &title)) {
       *error = ASCIIToUTF16(errors::kInvalidPageActionName);
-      return scoped_ptr<ExtensionAction>();
+      return scoped_ptr<ActionInfo>();
     }
   }
-  result->SetTitle(ExtensionAction::kDefaultTabId, title);
+  result->default_title = title;
 
   // Read the action's |popup| (optional).
   const char* popup_key = NULL;
   if (extension_action->HasKey(keys::kPageActionDefaultPopup))
     popup_key = keys::kPageActionDefaultPopup;
 
   if (manifest_version_ == 1 &&
       extension_action->HasKey(keys::kPageActionPopup)) {
     if (popup_key) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPageActionOldAndNewKeys,
           keys::kPageActionDefaultPopup,
           keys::kPageActionPopup);
-      return scoped_ptr<ExtensionAction>();
+      return scoped_ptr<ActionInfo>();
     }
     popup_key = keys::kPageActionPopup;
   }
 
   if (popup_key) {
     const DictionaryValue* popup = NULL;
     std::string url_str;
 
     if (extension_action->GetString(popup_key, &url_str)) {
       // On success, |url_str| is set.  Nothing else to do.
     } else if (manifest_version_ == 1 &&
                extension_action->GetDictionary(popup_key, &popup)) {
       if (!popup->GetString(keys::kPageActionPopupPath, &url_str)) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, "<missing>");
-        return scoped_ptr<ExtensionAction>();
+        return scoped_ptr<ActionInfo>();
       }
     } else {
       *error = ASCIIToUTF16(errors::kInvalidPageActionPopup);
-      return scoped_ptr<ExtensionAction>();
+      return scoped_ptr<ActionInfo>();
     }
 
     if (!url_str.empty()) {
       // An empty string is treated as having no popup.
       GURL url = GetResourceURL(url_str);
       if (!url.is_valid()) {
         *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, url_str);
-        return scoped_ptr<ExtensionAction>();
+        return scoped_ptr<ActionInfo>();
       }
-      result->SetPopupUrl(ExtensionAction::kDefaultTabId, url);
+      result->default_popup_url = url;
     } else {
-      DCHECK(!result->HasPopup(ExtensionAction::kDefaultTabId))
+      DCHECK(result->default_popup_url.is_empty())
           << "Shouldn't be possible for the popup to be set.";
     }
   }
 
   return result.Pass();
 }
 
 // static
 bool Extension::InitExtensionID(extensions::Manifest* manifest,
                                 const FilePath& path,
@@ skipping 1369 matching lines @@
   } else if (manifest_->HasKey(keys::kPageAction)) {
     if (!manifest_->GetDictionary(keys::kPageAction, &page_action_value)) {
       *error = ASCIIToUTF16(errors::kInvalidPageAction);
       return false;
     }
   }
 
   // If page_action_value is not NULL, then there was a valid page action.
   if (page_action_value) {
     page_action_ = LoadExtensionActionHelper(
-        page_action_value, ExtensionAction::TYPE_PAGE, error);
+        page_action_value, ActionInfo::TYPE_PAGE, error);
     if (!page_action_.get())
       return false;  // Failed to parse page action definition.
 
     // The action box changes the meaning of the page action area, so we need
     // to convert page actions into browser actions.
     if (switch_utils::AreScriptBadgesEnabled())
       browser_action_ = page_action_.Pass();
   }
 
   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_ = LoadExtensionActionHelper(
-      browser_action_value, ExtensionAction::TYPE_BROWSER, error);
+      browser_action_value, ActionInfo::TYPE_BROWSER, error);
   if (!browser_action_.get())
     return false;  // Failed to parse browser action definition.
   return true;
 }
 
 bool Extension::LoadScriptBadge(string16* error) {
   if (manifest_->HasKey(keys::kScriptBadge)) {
     if (!switch_utils::AreScriptBadgesEnabled()) {
       // So as to not confuse developers if they specify a script badge section
       // in the manifest, show a warning if the script badge declaration isn't
       // going to have any effect.
       install_warnings_.push_back(
           InstallWarning(InstallWarning::FORMAT_TEXT,
                          errors::kScriptBadgeRequiresFlag));
     }
 
     DictionaryValue* script_badge_value = NULL;
     if (!manifest_->GetDictionary(keys::kScriptBadge, &script_badge_value)) {
       *error = ASCIIToUTF16(errors::kInvalidScriptBadge);
       return false;
     }
 
     script_badge_ = LoadExtensionActionHelper(
-        script_badge_value, ExtensionAction::TYPE_SCRIPT_BADGE, error);
+        script_badge_value, ActionInfo::TYPE_SCRIPT_BADGE, error);
     if (!script_badge_.get())
       return false;  // Failed to parse script badge definition.
   } else {
-    script_badge_.reset(
-        new ExtensionAction(id(), ExtensionAction::TYPE_SCRIPT_BADGE));
+    script_badge_.reset(new ActionInfo(ActionInfo::TYPE_SCRIPT_BADGE));
   }
 
   // Script badges always use their extension's title and icon so users can rely
   // on the visual appearance to know which extension is running.  This isn't
   // bulletproof since an malicious extension could use a different 16x16 icon
   // that matches the icon of a trusted extension, and users wouldn't be warned
   // during installation.
 
-  if (!script_badge_->GetTitle(ExtensionAction::kDefaultTabId).empty()) {
+  if (!script_badge_->default_title.empty()) {
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeTitleIgnored));
   }
-  script_badge_->SetTitle(ExtensionAction::kDefaultTabId, name());
+  script_badge_->default_title = name();
 
-  if (!script_badge_->default_icon_path().empty()) {
+  if (!script_badge_->default_icon_path.empty()) {
     install_warnings_.push_back(
         InstallWarning(InstallWarning::FORMAT_TEXT,
                        errors::kScriptBadgeIconIgnored));
   }
-  std::string icon16_path = icons().Get(extension_misc::EXTENSION_ICON_BITTY,
-                                        ExtensionIconSet::MATCH_EXACTLY);
-  if (!icon16_path.empty()) {
-    script_badge_->set_default_icon_path(icon16_path);
-  } else {
-    script_badge_->SetIcon(
-        ExtensionAction::kDefaultTabId,
-        ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-            IDR_EXTENSIONS_FAVICON));
-  }
+
+  script_badge_->default_icon_path =
+      icons().Get(extension_misc::EXTENSION_ICON_BITTY,
+                  ExtensionIconSet::MATCH_EXACTLY);
 
   return true;
 }
 
 bool Extension::LoadFileBrowserHandlers(string16* error) {
   if (!manifest_->HasKey(keys::kFileBrowserHandlers))
     return true;
   ListValue* file_browser_handlers_value = NULL;
   if (!manifest_->GetList(keys::kFileBrowserHandlers,
                          &file_browser_handlers_value)) {
@@ skipping 798 matching lines @@
     for (DictionaryValue::key_iterator it = theme_images->begin_keys();
          it != theme_images->end_keys(); ++it) {
       std::string val;
       if (theme_images->GetStringWithoutPathExpansion(*it, &val))
         image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(val)));
     }
   }
 
   // Page action icons.
   if (page_action()) {
-    std::vector<std::string>* icon_paths = page_action()->icon_paths();
-    for (std::vector<std::string>::iterator iter = icon_paths->begin();
-         iter != icon_paths->end(); ++iter) {
-      image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(*iter)));
-    }
+    image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(
+        page_action()->default_icon_path)));
   }
 
   // Browser action icons.
   if (browser_action()) {
-    std::vector<std::string>* icon_paths = browser_action()->icon_paths();
-    for (std::vector<std::string>::iterator iter = icon_paths->begin();
-         iter != icon_paths->end(); ++iter) {
-      image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(*iter)));
-    }
+    image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(
+        browser_action()->default_icon_path)));
   }
 
   return image_paths;
 }
 
 GURL Extension::GetFullLaunchURL() const {
   return launch_local_path().empty() ? GURL(launch_web_url()) :
                                        url().Resolve(launch_local_path());
 }
 
@@ skipping 739 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions