Generate a browser action for any extension which doesn't have a browser or

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 2314 matching lines @@
     return false;
   }
 
   browser_action_ = LoadExtensionActionHelper(browser_action_value, error);
   if (!browser_action_.get())
     return false;  // Failed to parse browser action definition.
   extension_action_api_type_ = ExtensionAction::TYPE_BROWSER;
   return true;
 }
 
+void Extension::GenerateBrowserActionIfPossible() {

[Aaron Boodman, 2012/04/30 03:27:22]

IfNecessary?

[not at google - send to devlin, 2012/04/30 04:48:22]

Well, IfPossible is I think more accurate. I like the

if (!browser_action)
  GenerateBrowserAction();

logic rather than just always calling "GenerateBrowserActionIfNecessary()".  And
yeah, the only reason why a browser action wouldn't be generated is if they
aren't supported by the extension type, hence "IfPossible".  Actually I could
have left that suffix off entirely, it's kind of an implementation detail.

+  // It only makes sense to generate brower actions for extensions that are
+  // shown in chrome://extensions.
+  if (!ShouldDisplayInExtensionSettings())
+    return;
+
+  // Hosted and platform apps are shown in extension settings, but we don't
+  // want to generate browser actions for those either, since they can't define
+  // browser actions.
+  if (is_app())
+    return;
+
+  browser_action_.reset(new ExtensionAction(id()));
+  browser_action_->SetTitle(ExtensionAction::kDefaultTabId, name());
+}
+
 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 729 matching lines @@
 
   if (!LoadSharedFeatures(api_permissions, error))
     return false;
 
   if (!LoadExtensionFeatures(api_permissions, error))
     return false;
 
   if (!LoadThemeFeatures(error))
     return false;
 
+  if (CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kEnableBrowserActionsForAll) &&
+      !browser_action()) {
+    GenerateBrowserActionIfPossible();
+  }
+
   if (HasMultipleUISurfaces()) {
     *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
   runtime_data_.SetActivePermissions(new ExtensionPermissionSet(
       this, api_permissions, host_permissions, oauth2_info_.GetScopesAsSet()));
   required_permission_set_ = new ExtensionPermissionSet(
       this, api_permissions, host_permissions, oauth2_info_.GetScopesAsSet());
   optional_permission_set_ = new ExtensionPermissionSet(
@@ skipping 544 matching lines @@
                              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());
 }
 
+bool Extension::ShouldDisplayInExtensionSettings() const {
+  // Don't show for themes since the settings UI isn't really useful for them.
+  if (is_theme())
+    return false;
+
+  // Don't show component extensions because they are only extensions as an
+  // implementation detail of Chrome.
+  if (location() == Extension::COMPONENT &&
+      !CommandLine::ForCurrentProcess()->HasSwitch(
+        switches::kShowComponentExtensionOptions))
+    return false;
+
+  // Always show unpacked extensions and apps.
+  if (location() == Extension::LOAD)
+    return true;
+
+  // Unless they are unpacked, never show hosted apps. Note: We intentionally
+  // show packaged apps and platform apps because there are some pieces of
+  // functionality that are only available in chrome://extensions/ but which
+  // are needed for packaged and platform apps. For example, inspecting
+  // background pages. See http://crbug.com/116134.
+  if (is_hosted_app())
+    return false;
+
+  return true;
+}
+
 ExtensionInfo::~ExtensionInfo() {}
 
 Extension::RuntimeData::RuntimeData() {}
 Extension::RuntimeData::RuntimeData(const ExtensionPermissionSet* active)
     : active_permissions_(active) {}
 Extension::RuntimeData::~RuntimeData() {}
 
 scoped_refptr<const ExtensionPermissionSet>
     Extension::RuntimeData::GetActivePermissions() const {
   return active_permissions_;
@@ skipping 11 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}