Implement Browser Actions extensions....

chrome/common/extensions/extension.cc

 // Copyright (c) 2009 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 "app/resource_bundle.h"
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
+#include "base/stl_util-inl.h"
 #include "base/third_party/nss/blapi.h"
 #include "base/third_party/nss/sha256.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 #include "net/base/base64.h"
@@ skipping 76 matching lines @@
 };
 
 const char* Extension::kPermissionNames[] = {
   "tabs",
   "bookmarks",
 };
 const size_t Extension::kNumPermissions =
     arraysize(Extension::kPermissionNames);
 
 Extension::~Extension() {
-  for (PageActionMap::iterator i = page_actions_.begin();
-       i != page_actions_.end(); ++i)
-    delete i->second;
+  STLDeleteValues(&page_actions_);
+  delete browser_action_;

[Erik does not do reviews, 2009/09/25 22:56:11]

just change this to a scoped_ptr

 }
 
 const std::string Extension::VersionString() const {
   return version_->GetString();
 }
 
 // static
 bool Extension::IsExtension(const FilePath& file_name) {
   return file_name.MatchesExtension(
       FilePath::StringType(FILE_PATH_LITERAL(".")) +
@@ skipping 21 matching lines @@
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK(extension_url.path() == "/");
 
   GURL ret_val = GURL(extension_url.spec() + relative_path);
   DCHECK(StartsWithASCII(ret_val.spec(), extension_url.spec(), false));
 
   return ret_val;
 }
 
-const PageAction* Extension::GetPageAction(std::string id) const {
-  PageActionMap::const_iterator it = page_actions_.find(id);
-  if (it == page_actions_.end())
-    return NULL;
+const ContextualAction* Extension::GetContextualAction(
+    std::string id, ContextualAction::ContextualActionType action_type) const {
+  if (action_type == ContextualAction::BROWSER_ACTION) {
+    return browser_action_;

[Erik does not do reviews, 2009/09/25 22:56:11]

DCHECK(id.empty())

+  } else {
+    ContextualActionMap::const_iterator it = page_actions_.find(id);
+    if (it == page_actions_.end())
+      return NULL;
 
-  return it->second;
+    return it->second;
+  }
 }
 
 Extension::Location Extension::ExternalExtensionInstallType(
     std::string registry_path) {
 #if defined(OS_WIN)
   HKEY reg_root = HKEY_LOCAL_MACHINE;
   RegKey key;
   registry_path.append("\\");
   registry_path.append(id_);
   if (key.Open(reg_root, ASCIIToWide(registry_path).c_str()))
@@ skipping 130 matching lines @@
       // TODO(georged): Make GetResourceURL accept wstring too
       GURL url = GetResourceURL(WideToUTF8(relative));
       FilePath path = GetResourcePath(WideToUTF8(relative));
       result->css_scripts().push_back(UserScript::File(path, url));
     }
   }
 
   return true;
 }
 
-// Helper method that loads a PageAction object from a dictionary in the
-// page_action list of the manifest.
-PageAction* Extension::LoadPageActionHelper(
+// Helper method that loads a PageAction or BrowserAction object from a
+// dictionary in the page_actions list or browser_action key of the manifest.
+ContextualAction* Extension::LoadContextualActionHelper(
     const DictionaryValue* page_action, int definition_index,
-    std::string* error) {
-  scoped_ptr<PageAction> result(new PageAction());
+    std::string* error, ContextualAction::ContextualActionType action_type) {
+  scoped_ptr<ContextualAction> result(new ContextualAction());
   result->set_extension_id(id());
+  result->set_type(action_type);
 
   ListValue* icons;
   // Read the page action |icons|.
   if (!page_action->HasKey(keys::kPageActionIcons) ||
       !page_action->GetList(keys::kPageActionIcons, &icons) ||
       icons->GetSize() == 0) {
     *error = ExtensionErrorUtils::FormatErrorMessage(
         errors::kInvalidPageActionIconPaths, IntToString(definition_index));
     return NULL;
   }
 
   int icon_count = 0;
   for (ListValue::const_iterator iter = icons->begin();
        iter != icons->end(); ++iter) {
     std::string path;
     if (!(*iter)->GetAsString(&path) || path.empty()) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidPageActionIconPath,
           IntToString(definition_index), IntToString(icon_count));
       return NULL;
     }
 
     result->AddIconPath(path);
     ++icon_count;
   }
 
-  // Read the page action |id|.
-  std::string id;
-  if (!page_action->GetString(keys::kPageActionId, &id)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(
-        errors::kInvalidPageActionId, IntToString(definition_index));
-    return NULL;
+  if (action_type == ContextualAction::BROWSER_ACTION) {
+    result->set_id("");  // Not needed (only 1 browser action per extension).
+  } else {
+    // Read the page action |id|.
+    std::string id;
+    if (!page_action->GetString(keys::kPageActionId, &id)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(
+          errors::kInvalidPageActionId, IntToString(definition_index));
+      return NULL;
+    }
+    result->set_id(id);
   }
-  result->set_id(id);
 
   // Read the page action |name|.
   std::string name;
   if (!page_action->GetString(keys::kName, &name)) {
     *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidName,
         IntToString(definition_index));
     return NULL;
   }
   result->set_name(name);
 
-  // Read the page action |type|. It is optional and set to permanent if
-  // missing.
-  std::string type;
-  if (!page_action->GetString(keys::kType, &type)) {
-    result->set_type(PageAction::PERMANENT);
-  } else if (!LowerCaseEqualsASCII(type, values::kPageActionTypeTab) &&
-             !LowerCaseEqualsASCII(type, values::kPageActionTypePermanent)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(
-        errors::kInvalidPageActionTypeValue, IntToString(definition_index));
-    return NULL;
-  } else {
-    if (LowerCaseEqualsASCII(type, values::kPageActionTypeTab))
-      result->set_type(PageAction::TAB);
-    else
-      result->set_type(PageAction::PERMANENT);
-  }
-
   return result.release();
 }
 
 bool Extension::ContainsNonThemeKeys(const DictionaryValue& source) {
   // Generate a map of allowable keys
   static std::map<std::wstring, bool> theme_keys;
   static bool theme_key_mapped = false;
   if (!theme_key_mapped) {
     for (size_t i = 0; i < arraysize(kValidThemeKeys); ++i) {
       theme_keys[kValidThemeKeys[i]] = true;
@@ skipping 42 matching lines @@
 
   // Double-check that the path we ended up with is actually inside the
   // extension root.
   if (!extension_path.IsParent(ret_val))
     return FilePath();
 
   return ret_val;
 }
 
 Extension::Extension(const FilePath& path)
-    : is_theme_(false), background_page_ready_(false) {
+    : browser_action_(NULL), is_theme_(false), background_page_ready_(false) {
   DCHECK(path.IsAbsolute());
   location_ = INVALID;
 
 #if defined(OS_WIN)
   // Normalize any drive letter to upper-case. We do this for consistency with
   // net_utils::FilePathToFileURL(), which does the same thing, to make string
   // comparisons simpler.
   std::wstring path_str = path.value();
   if (path_str.size() >= 2 && path_str[0] >= L'a' && path_str[0] <= L'z' &&
       path_str[1] == ':')
@@ skipping 483 matching lines @@
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* page_action_value;
       if (!list_value->GetDictionary(i, &page_action_value)) {
         *error = ExtensionErrorUtils::FormatErrorMessage(
             errors::kInvalidPageAction, IntToString(i));
         return false;
       }
 
-      PageAction* page_action =
-          LoadPageActionHelper(page_action_value, i, error);
-      if (!page_action)
+      ContextualAction* contextual_action =
+          LoadContextualActionHelper(page_action_value, i, error,
+                                     ContextualAction::PAGE_ACTION);
+      if (!contextual_action)
         return false;  // Failed to parse page action definition.
-      page_actions_[page_action->id()] = page_action;
+      page_actions_[contextual_action->id()] = contextual_action;
     }
   }
 
+  if (source.HasKey(keys::kBrowserAction)) {
+    DictionaryValue* browser_action_value;
+    if (!source.GetDictionary(keys::kBrowserAction, &browser_action_value)) {
+      *error = ExtensionErrorUtils::FormatErrorMessage(
+          errors::kInvalidBrowserAction, "");
+      return false;
+    }
+
+    browser_action_ =
+        LoadContextualActionHelper(browser_action_value, 0, error,
+                                   ContextualAction::BROWSER_ACTION);
+    if (!browser_action_)
+      return false;  // Failed to parse browser action definition.
+  }
+
   // Initialize the permissions (optional).
   if (source.HasKey(keys::kPermissions)) {
     ListValue* permissions = NULL;
     if (!source.GetList(keys::kPermissions, &permissions)) {
       *error = ExtensionErrorUtils::FormatErrorMessage(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
@@ skipping 83 matching lines @@
     for (DictionaryValue::key_iterator it = theme_images->begin_keys();
          it != theme_images->end_keys(); ++it) {
       std::wstring val;
       if (theme_images->GetString(*it, &val)) {
         image_paths.insert(FilePath::FromWStringHack(val));
       }
     }
   }
 
   // page action icons
-  for (PageActionMap::const_iterator it = page_actions().begin();
+  for (ContextualActionMap::const_iterator it = page_actions().begin();
        it != page_actions().end(); ++it) {
     const std::vector<std::string>& icon_paths = it->second->icon_paths();
     for (std::vector<std::string>::const_iterator iter = icon_paths.begin();
          iter != icon_paths.end(); ++iter) {
       image_paths.insert(FilePath::FromWStringHack(UTF8ToWide(*iter)));
     }
   }
 
   return image_paths;
 }
@@ skipping 59 matching lines @@
     UserScript::PatternList::const_iterator pattern =
         content_script->url_patterns().begin();
     for (; pattern != content_script->url_patterns().end(); ++pattern) {
       if (pattern->match_subdomains() && pattern->host().empty())
         return true;
     }
   }
 
   return false;
 }