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 391 matching lines @@
 const std::string Extension::VersionString() const {
   return version()->GetString();
 }
 
 void Extension::AddInstallWarnings(
     const InstallWarningVector& new_warnings) {
   install_warnings_.insert(install_warnings_.end(),
                            new_warnings.begin(), new_warnings.end());
 }
 
+void Extension::AddDeveloperInstallWarning(
+    InstallWarning::Format format,
+    const std::string& message) {
+  if (location() == LOAD)

[not at google - send to devlin, 2012/06/18 22:59:41]

Install warnings only show up when developer mode has been turned on anyway...
as in, the "developer" is a tautology.

(ny all means have a function for adding a single warning, but only needs to be
called AddInstallWarning)

[Jeffrey Yasskin, 2012/06/18 23:58:42]

My idea here was that it would show up for extensions that are under development
but not extensions that were merely installed. There's another example of this
for the manifest_version_==1 warning, but I don't see any others.

If it shouldn't filter on location()==LOAD, I don't think we need a helper
function for this, so I've removed the filter.

[not at google - send to devlin, 2012/06/19 00:27:32]

Yeah, makes sense. I'm just saying that this happens automatically kind of,
because most people don't have developer mode turned on.

+    install_warnings_.push_back(InstallWarning(format, message));
+}
+
 // static
 bool Extension::IsExtension(const FilePath& file_name) {
   return file_name.MatchesExtension(chrome::kExtensionFileExtension);
 }
 
 // static
 bool Extension::IdIsValid(const std::string& id) {
   // Verify that the id is legal.
   if (id.size() != (kIdSize * 2))
     return false;
@@ skipping 366 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) {
+      AddDeveloperInstallWarning(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::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()) {

[not at google - send to devlin, 2012/06/18 22:59:41]

(has been submitted now btw)

[Jeffrey Yasskin, 2012/06/18 23:58:42]

And I've now synced past it.

+    if (manifest_->HasKey(keys::kScriptBadge)) {
+      AddDeveloperInstallWarning(InstallWarning::FORMAT_TEXT,
+                                 errors::kScriptBadgeRequiresActionBox);
+    }
+    return true;

[not at google - send to devlin, 2012/06/18 22:59:41]

Could we just generate a warning here and not early-exit? I know that it would
result in redundantly generating a script badge if the flag is off, but I don't
think that's a big deal (it's just going to be turned on by default soon anyway)
and it means that we have less logic that's divergent on command line flags (and
logic that's divergent on command line flags is confusing and increasingly hard
to follow). It also means no setting up command line flag stuff for unit tests
as I mentioned earlier.

E.g. how about just:

// 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.
if (!switch_utils::AreScriptBadgeEnabled() &&
     manifest_HasKey(keys::kScriptBadge)) {
  AddInstallWarning();
}

[Jeffrey Yasskin, 2012/06/18 23:58:42]

Sure. Then script_badge_ should never be null.

+  }
+
+  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 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.
+
+  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 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