Parse the script_badge manifest section.

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"
@@ skipping 777 matching lines @@
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
 scoped_ptr<ExtensionAction> Extension::LoadExtensionActionHelper(
-    const DictionaryValue* extension_action, string16* error) {
+    const DictionaryValue* extension_action,
+    ExtensionAction::Type action_type,
+    string16* error) {
   scoped_ptr<ExtensionAction> result(new ExtensionAction(id()));
 
   // Page actions are hidden by default, and browser actions ignore
   // visibility.
   result->SetIsVisible(ExtensionAction::kDefaultTabId, false);
 
   if (manifest_version_ == 1) {
     ListValue* icons = NULL;
     if (extension_action->HasKey(keys::kPageActionIcons) &&
         extension_action->GetList(keys::kPageActionIcons, &icons)) {
@@ skipping 15 matching lines @@
         *error = ASCIIToUTF16(errors::kInvalidPageActionId);
         return scoped_ptr<ExtensionAction>();
       }
       result->set_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>();
+    if (action_type == ExtensionAction::TYPE_SCRIPT_BADGE) {
+      install_warnings_.push_back(
+          InstallWarning(InstallWarning::FORMAT_TEXT,
+                         errors::kScriptBadgeIconIgnored));
+    } else {
+      if (!extension_action->GetString(keys::kPageActionDefaultIcon,
+                                       &default_icon) ||
+          default_icon.empty()) {
+        *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
+        return scoped_ptr<ExtensionAction>();
+      }
+      result->set_default_icon_path(default_icon);
     }
-    result->set_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>();
     }
@@ skipping 1162 matching lines @@
     string16* error) {
   if (manifest_->HasKey(keys::kConvertedFromUserScript))
     manifest_->GetBoolean(keys::kConvertedFromUserScript,
                           &converted_from_user_script_);
 
   if (!LoadDevToolsPage(error) ||
       !LoadInputComponents(api_permissions, error) ||
       !LoadContentScripts(error) ||
       !LoadPageAction(error) ||
       !LoadBrowserAction(error) ||
+      !LoadScriptBadge(error) ||
       !LoadFileBrowserHandlers(error) ||
       !LoadChromeURLOverrides(error) ||
       !LoadOmnibox(error) ||
       !LoadTextToSpeechVoices(error) ||
       !LoadIncognitoMode(error) ||
       !LoadContentSecurityPolicy(error))
     return false;
 
   return true;
 }
@@ skipping 200 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, error);
+    page_action_ = LoadExtensionActionHelper(
+        page_action_value, ExtensionAction::TYPE_PAGE, error);
     if (!page_action_.get())
       return false;  // Failed to parse page action definition.
     declared_action_type_ = ExtensionAction::TYPE_PAGE;
 
     // 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();
       // declared_action_type_ stays the same; that's the point.
     }
   }
 
   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, error);
+  browser_action_ = LoadExtensionActionHelper(
+      browser_action_value, ExtensionAction::TYPE_BROWSER, error);
   if (!browser_action_.get())
     return false;  // Failed to parse browser action definition.
   declared_action_type_ = ExtensionAction::TYPE_BROWSER;
   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);
+    if (!script_badge_.get())
+      return false;  // Failed to parse script badge definition.
+
+    declared_action_type_ = ExtensionAction::TYPE_SCRIPT_BADGE;
+  } else {
+    script_badge_.reset(new ExtensionAction(id()));
+
+    // Make sure there is always a title.
+    script_badge_->SetTitle(ExtensionAction::kDefaultTabId, name());
+  }
+
+  // Script badges always use their extension's 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.
+
+  std::string icon16_path = icons().Get(ExtensionIconSet::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).ToSkBitmap());
+  }
+
+  script_badge_->SetIsVisible(ExtensionAction::kDefaultTabId, true);
+
+  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)) {
     *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
     return false;
   }
   file_browser_handlers_.reset(
@@ skipping 1319 matching lines @@
   // We want to sync any extensions that are internal and the chrome web store.
   return location() == Extension::INTERNAL ||
       id() == extension_misc::kWebStoreAppId;
 }
 
 bool Extension::ShouldDisplayInLauncher() const {
   // All apps should be displayed on the NTP except for the Cloud Print App.
   return is_app() && id() != extension_misc::kCloudPrintAppId;
 }
 
+bool Extension::InstallWarning::operator==(const InstallWarning& other) const {
+  return format == other.format && message == other.message;
+}
+
+void PrintTo(const Extension::InstallWarning& warning, ::std::ostream* os){
+  *os << "InstallWarning(";
+  switch (warning.format) {
+    case Extension::InstallWarning::FORMAT_TEXT:
+      *os << "FORMAT_TEXT, \"";
+      break;
+    case Extension::InstallWarning::FORMAT_HTML:
+      *os << "FORMAT_HTML, \"";
+      break;
+  }
+  // This is just for test error messages, so no need to escape '"'
+  // characters inside the message.
+  *os << warning.message << "\")";
+}
+
 ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
                              const std::string& id,
                              const FilePath& path,
                              Extension::Location location)
     : extension_id(id),
       extension_path(path),
       extension_location(location) {
   if (manifest)
     extension_manifest.reset(manifest->DeepCopy());
 }
@@ skipping 27 matching lines @@
 
 bool Extension::HasContentScriptAtURL(const GURL& url) const {
   for (UserScriptList::const_iterator it = content_scripts_.begin();
       it != content_scripts_.end(); ++it) {
     if (it->MatchesURL(url))
       return true;
   }
   return false;
 }
 
-ExtensionAction* Extension::GetScriptBadge() const {
-  if (!script_badge_.get()) {
-    script_badge_.reset(new ExtensionAction(id()));
-
-    // On initialization, copy the default icon path from the browser action,
-    // or generate a puzzle piece if there isn't one. Extensions may later
-    // overwrite this icon using the browserAction API.
-    if (browser_action() && !browser_action()->default_icon_path().empty()) {
-      script_badge_->set_default_icon_path(
-          browser_action()->default_icon_path());
-    } else {
-      script_badge_->SetIcon(
-          ExtensionAction::kDefaultTabId,
-          *ui::ResourceBundle::GetSharedInstance().GetImageNamed(
-              IDR_EXTENSIONS_FAVICON).ToSkBitmap());
-    }
-
-    // Likewise, make sure there is always a title.
-    script_badge_->SetTitle(ExtensionAction::kDefaultTabId, name());
-  }
-
-  // Every time, re-initialize the script badge based on the current state of
-  // the browser action.
-  int kDefaultTabId = ExtensionAction::kDefaultTabId;
-
-  script_badge_->SetIsVisible(kDefaultTabId, true);
-
-  if (browser_action()) {
-    SkBitmap icon = browser_action()->GetIcon(kDefaultTabId);
-    if (!icon.isNull())
-      script_badge_->SetIcon(kDefaultTabId, icon);
-
-    std::string title = browser_action()->GetTitle(kDefaultTabId);
-    if (!title.empty())
-      script_badge_->SetTitle(kDefaultTabId, title);
-  }
-
-  return script_badge_.get();
-}
-
 const URLPatternSet* Extension::GetTabSpecificHostPermissions(
     int tab_id) const {
   base::AutoLock auto_lock(runtime_data_lock_);
   return runtime_data_.GetTabSpecificHostPermissions(tab_id);
 }
 
 void Extension::SetTabSpecificHostPermissions(
     int tab_id,
     const URLPatternSet& permissions) const {
   base::AutoLock auto_lock(runtime_data_lock_);
@@ skipping 80 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions