Move ScriptBadge, ActionInfo out of Extension; preparation for BrowserAction

chrome/common/extensions/extension.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/common/extensions/extension.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"
+// TODO(rdevlin.cronin): Remove this once PageAction, BrowserAction, and
+// SystemIndicator have been moved out of Extension.
+#include "chrome/common/extensions/api/extension_action/action_info.h"
 #include "chrome/common/extensions/csp_validator.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/base_feature_provider.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
+#include "chrome/common/extensions/manifest_handler_helpers.h"
 #include "chrome/common/extensions/manifest_url_handler.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
 #include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
@@ skipping 73 matching lines @@
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
                                                id->begin() + i + 1),
                              &val)) {
       (*id)[i] = val + 'a';
     } else {
       (*id)[i] = 'a';
     }
   }
 }
 
-// Strips leading slashes from the file path. Returns true iff the final path is
-// non empty.
-bool NormalizeAndValidatePath(std::string* path) {
-  size_t first_non_slash = path->find_first_not_of('/');
-  if (first_non_slash == std::string::npos) {
-    *path = "";
-    return false;
-  }
-
-  *path = path->substr(first_non_slash);
-  return true;
-}
-
-// Loads icon paths defined in dictionary |icons_value| into ExtensionIconSet
-// |icons|. |icons_value| is a dictionary value {icon size -> icon path}. Icons
-// in |icons_value| whose size is not in |icon_sizes| will be ignored.
-// Returns success. If load fails, |error| will be set.
-bool LoadIconsFromDictionary(const DictionaryValue* icons_value,
-                             const int* icon_sizes,
-                             size_t num_icon_sizes,
-                             ExtensionIconSet* icons,
-                             string16* error) {
-  DCHECK(icons);
-  for (size_t i = 0; i < num_icon_sizes; ++i) {
-    std::string key = base::IntToString(icon_sizes[i]);
-    if (icons_value->HasKey(key)) {
-      std::string icon_path;
-      if (!icons_value->GetString(key, &icon_path)) {
-        *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidIconPath, key);
-        return false;
-      }
-
-      if (!NormalizeAndValidatePath(&icon_path)) {
-        *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidIconPath, key);
-        return false;
-      }
-
-      icons->Add(icon_sizes[i], icon_path);
-    }
-  }
-  return true;
-}
-
 // A singleton object containing global data needed by the extension objects.
 class ExtensionConfig {
  public:
   static ExtensionConfig* GetInstance() {
     return Singleton<ExtensionConfig>::get();
   }
 
   Extension::ScriptingWhitelist* whitelist() { return &scripting_whitelist_; }
 
  private:
@@ skipping 113 matching lines @@
     if ((*i)->ManifestEntryForbidden()) {
       *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kPermissionNotAllowedInManifest,
           (*i)->info()->name());
       return true;
     }
   }
   return false;
 }
 
+// Helper method to load an ExtensionAction from the page_action, script_badge,
+// browser_action, or system_indicator entries in the manifest.
+// TODO(rdevlin.cronin): Remove this once PageAction, BrowserAction, and
+// SystemIndicator have been moved out of Extension.
+scoped_ptr<ActionInfo> LoadExtensionActionInfoHelper(
+    const Extension* extension,
+    const DictionaryValue* extension_action,
+    string16* error) {
+  return manifest_handler_helpers::LoadActionInfo(
+      extension, extension_action, error);
+}
+
 }  // namespace
 
 const FilePath::CharType Extension::kManifestFilename[] =
     FILE_PATH_LITERAL("manifest.json");
 const FilePath::CharType Extension::kLocaleFolder[] =
     FILE_PATH_LITERAL("_locales");
 const FilePath::CharType Extension::kMessagesFilename[] =
     FILE_PATH_LITERAL("messages.json");
 
 #if defined(OS_WIN)
@@ skipping 19 matching lines @@
     : webgl(false),
       css3d(false),
       npapi(false) {
 }
 
 Extension::Requirements::~Requirements() {}
 
 Extension::OAuth2Info::OAuth2Info() {}
 Extension::OAuth2Info::~OAuth2Info() {}
 
-Extension::ActionInfo::ActionInfo() {}
-Extension::ActionInfo::~ActionInfo() {}
-
 //
 // Extension
 //
 
 bool Extension::InstallWarning::operator==(const InstallWarning& other) const {
   return format == other.format && message == other.message;
 }
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
@@ skipping 928 matching lines @@
 }
 
 const std::string& Extension::id() const {
   return manifest_->extension_id();
 }
 
 const std::string Extension::VersionString() const {
   return version()->GetString();
 }
 
+void Extension::AddInstallWarning(const InstallWarning& new_warning) {
+  install_warnings_.push_back(new_warning);
+}
+
 void Extension::AddInstallWarnings(
     const InstallWarningVector& new_warnings) {
   install_warnings_.insert(install_warnings_.end(),
                            new_warnings.begin(), new_warnings.end());
 }
 
 bool Extension::is_platform_app() const {
   return manifest_->is_platform_app();
 }
 
@@ skipping 712 matching lines @@
 
 bool Extension::LoadIcons(string16* error) {
   if (!manifest_->HasKey(keys::kIcons))
     return true;
   DictionaryValue* icons_value = NULL;
   if (!manifest_->GetDictionary(keys::kIcons, &icons_value)) {
     *error = ASCIIToUTF16(errors::kInvalidIcons);
     return false;
   }
 
-  return LoadIconsFromDictionary(icons_value,
-                                 extension_misc::kExtensionIconSizes,
-                                 extension_misc::kNumExtensionIconSizes,
-                                 &icons_,
-                                 error);
+  return manifest_handler_helpers::LoadIconsFromDictionary(
+      icons_value,
+      extension_misc::kExtensionIconSizes,
+      extension_misc::kNumExtensionIconSizes,
+      &icons_,
+      error);
 }
 
 bool Extension::LoadCommands(string16* error) {
   if (manifest_->HasKey(keys::kCommands)) {
     DictionaryValue* commands = NULL;
     if (!manifest_->GetDictionary(keys::kCommands, &commands)) {
       *error = ASCIIToUTF16(errors::kInvalidCommandsKey);
       return false;
     }
 
@@ skipping 466 matching lines @@
                                       string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadManifestHandlerFeatures(error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
       !LoadBrowserAction(error) ||
       !LoadSystemIndicator(api_permissions, error) ||
-      !LoadScriptBadge(error) ||
       !LoadIncognitoMode(error) ||
       !LoadContentSecurityPolicy(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadManifestHandlerFeatures(string16* error) {
   std::vector<std::string> keys = ManifestHandler::GetKeys();
   for (size_t i = 0; i < keys.size(); ++i) {
@@ skipping 65 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_info_ = LoadExtensionActionInfoHelper(
-        page_action_value, Extension::ActionInfo::TYPE_PAGE, error);
+        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(
-      browser_action_value, Extension::ActionInfo::TYPE_BROWSER, error);
+      this, browser_action_value, error);
   if (!browser_action_info_.get())
     return false;  // Failed to parse browser action definition.
   return true;
 }
 
-bool Extension::LoadScriptBadge(string16* error) {
-  if (manifest_->HasKey(keys::kScriptBadge)) {
-    if (!FeatureSwitch::script_badges()->IsEnabled()) {
-      // 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_info_ = LoadExtensionActionInfoHelper(
-        script_badge_value, Extension::ActionInfo::TYPE_SCRIPT_BADGE, error);
-    if (!script_badge_info_.get())
-      return false;  // Failed to parse script badge definition.
-  } else {
-    script_badge_info_.reset(new ActionInfo());
-  }
-
-  // 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_info_->default_title.empty()) {
-    install_warnings_.push_back(
-        InstallWarning(InstallWarning::FORMAT_TEXT,
-                       errors::kScriptBadgeTitleIgnored));
-  }
-  script_badge_info_->default_title = name();
-
-  if (!script_badge_info_->default_icon.empty()) {
-    install_warnings_.push_back(
-        InstallWarning(InstallWarning::FORMAT_TEXT,
-                       errors::kScriptBadgeIconIgnored));
-  }
-
-  script_badge_info_->default_icon.Clear();
-  for (size_t i = 0; i < extension_misc::kNumScriptBadgeIconSizes; i++) {
-    std::string path = icons().Get(extension_misc::kScriptBadgeIconSizes[i],
-                                   ExtensionIconSet::MATCH_BIGGER);
-    if (!path.empty())
-      script_badge_info_->default_icon.Add(
-          extension_misc::kScriptBadgeIconSizes[i], path);
-  }
-
-  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)) {
     *error = ASCIIToUTF16(errors::kInvalidSystemIndicator);
     return false;
   }
 
   system_indicator_info_ = LoadExtensionActionInfoHelper(
-      system_indicator_value,
-      Extension::ActionInfo::TYPE_SYSTEM_INDICATOR,
-      error);
+      this, system_indicator_value, error);
 
   if (!system_indicator_info_.get()) {
     return false;
   }
 
   // Because the manifest was successfully parsed, auto-grant the permission.
   // TODO(dewittj) Add this for all extension action APIs.
   api_permissions->insert(APIPermission::kSystemIndicator);
 
   return true;
@@ skipping 418 matching lines @@
           base::IntToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
-scoped_ptr<Extension::ActionInfo> Extension::LoadExtensionActionInfoHelper(
-    const DictionaryValue* extension_action,
-    ActionInfo::Type action_type,
-    string16* error) {
-  scoped_ptr<ActionInfo> result(new ActionInfo());
-
-  if (manifest_version_ == 1) {
-    // kPageActionIcons is obsolete, and used by very few extensions. Continue
-    // loading it, but only take the first icon as the default_icon path.
-    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) || !NormalizeAndValidatePath(&path)) {
-          *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
-          return scoped_ptr<ActionInfo>();
-        }
-
-        result->default_icon.Add(extension_misc::EXTENSION_ICON_ACTION, 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<ActionInfo>();
-      }
-      result->id = id;
-    }
-  }
-
-  // Read the page action |default_icon| (optional).
-  // The |default_icon| value can be either dictionary {icon size -> icon path}
-  // or non empty string value.
-  if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
-    const DictionaryValue* icons_value = NULL;
-    std::string default_icon;
-    if (extension_action->GetDictionary(keys::kPageActionDefaultIcon,
-                                        &icons_value)) {
-      if (!LoadIconsFromDictionary(icons_value,
-                                   extension_misc::kExtensionActionIconSizes,
-                                   extension_misc::kNumExtensionActionIconSizes,
-                                   &result->default_icon,
-                                   error)) {
-        return scoped_ptr<ActionInfo>();
-      }
-    } else if (extension_action->GetString(keys::kPageActionDefaultIcon,
-                                           &default_icon) &&
-               NormalizeAndValidatePath(&default_icon)) {
-      result->default_icon.Add(extension_misc::EXTENSION_ICON_ACTION,
-                               default_icon);
-    } else {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
-      return scoped_ptr<ActionInfo>();
-    }
-  }
-
-  // Read the page action title from |default_title| if present, |name| if not
-  // (both optional).
-  if (extension_action->HasKey(keys::kPageActionDefaultTitle)) {
-    if (!extension_action->GetString(keys::kPageActionDefaultTitle,
-                                     &result->default_title)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
-      return scoped_ptr<ActionInfo>();
-    }
-  } else if (manifest_version_ == 1 && extension_action->HasKey(keys::kName)) {
-    if (!extension_action->GetString(keys::kName, &result->default_title)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionName);
-      return scoped_ptr<ActionInfo>();
-    }
-  }
-
-  // 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 = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidPageActionOldAndNewKeys,
-          keys::kPageActionDefaultPopup,
-          keys::kPageActionPopup);
-      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 = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidPageActionPopupPath, "<missing>");
-        return scoped_ptr<ActionInfo>();
-      }
-    } else {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionPopup);
-      return scoped_ptr<ActionInfo>();
-    }
-
-    if (!url_str.empty()) {
-      // An empty string is treated as having no popup.
-      result->default_popup_url = GetResourceURL(url_str);
-      if (!result->default_popup_url.is_valid()) {
-        *error = ErrorUtils::FormatErrorMessageUTF16(
-            errors::kInvalidPageActionPopupPath, url_str);
-        return scoped_ptr<ActionInfo>();
-      }
-    } else {
-      DCHECK(result->default_popup_url.is_empty())
-          << "Shouldn't be possible for the popup to be set.";
-    }
-  }
-
-  return result.Pass();
-}
-
 bool Extension::LoadOAuth2Info(string16* error) {
   if (!manifest_->HasKey(keys::kOAuth2))
     return true;
 
   if (!manifest_->GetString(keys::kOAuth2ClientId, &oauth2_info_.client_id) ||
       oauth2_info_.client_id.empty()) {
     *error = ASCIIToUTF16(errors::kInvalidOAuth2ClientId);
     return false;
   }
 
@@ skipping 199 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions