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 "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 783 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 (action_type == ExtensionAction::TYPE_SCRIPT_BADGE) {
+      *error = ASCIIToUTF16(errors::kScriptBadgeCannotSpecifyIcon);

[Aaron Boodman, 2012/06/16 01:50:38]

Same here, I don't think we should throw an error in this case. If you want you
could make it an install_warning.

[Jeffrey Yasskin, 2012/06/18 22:16:03]

Turned it into an install_warning that only developers see. 

+      return scoped_ptr<ExtensionAction>();
+    }
     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);
   }
 
   // Read the page action title from |default_title| if present, |name| if not
@@ skipping 1169 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::IsActionBoxEnabled()) {
       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) {
+  DictionaryValue* script_badge_value = NULL;
+
+  if (!switch_utils::IsActionBoxEnabled()) {

[Aaron Boodman, 2012/06/16 01:50:38]

Note: This is going to become AreScriptBadgesEnabled() soon (kalman has cl
pending).

[not at google - send to devlin, 2012/06/18 18:51:24]

It's in the CQ.

[Jeffrey Yasskin, 2012/06/18 22:16:03]

I haven't synced to this yet, but I will soon.

+    if (manifest_->HasKey(keys::kScriptBadge)) {

[Aaron Boodman, 2012/06/16 01:50:38]

This is not necessary. The manifest key will be locked to dev or canary channel.
We can just ignore the API when it is used w/o script badges enabled.

[Jeffrey Yasskin, 2012/06/18 22:16:03]

I'm a bit worried about developers using the script_badge section and then
getting confused when it's ignored. I'll make this a warning for location==LOAD
like you suggested for default_icon.

+      *error = ASCIIToUTF16(errors::kScriptBadgeRequiresActionBox);
+      return false;

[not at google - send to devlin, 2012/06/18 18:51:24]

Aaron are you saying to delete this whole block that's guarded by
IsActionBoxEnabled / AreScriptBadgesEnabled?

If so, yeah, I think that's sensible. It's unfortunate that this code
necessitates all that extra code in switch_utils. If we handle the lack of the
switch at a higher level (e.g. only constructing the ScriptBadgeController if
the flag is on, as we currently do) then that simplifies things a lot.

[Aaron Boodman, 2012/06/18 21:36:21]

yes, or rather:

if (!manifest->HasKey(...))
  return true;

[Jeffrey Yasskin, 2012/06/18 22:16:03]

We need to generate a script_badge object even when there's no script_badge
section in the manifest, to support the ScriptBadgeController, right?

+    }
+    return true;
+  }
+
+  if (manifest_->HasKey(keys::kScriptBadge)) {
+    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 page action definition.

[not at google - send to devlin, 2012/06/18 18:51:24]

s/page action/script badge/

[Jeffrey Yasskin, 2012/06/18 22:16:03]

Whoops, done.

+    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 badges so users can

[Aaron Boodman, 2012/06/16 01:50:38]

extension's icon

[Jeffrey Yasskin, 2012/06/18 22:16:03]

Done.

+  // 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.
+
+  script_badge_->set_default_icon_path(
+      icons().Get(ExtensionIconSet::EXTENSION_ICON_BITTY,
+                  ExtensionIconSet::MATCH_BIGGER));
+
+  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 1366 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