Include individual share intents in the action box and allow direct triggering without an intermedi…

chrome/browser/ui/toolbar/action_box_button_controller.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/browser/ui/toolbar/action_box_button_controller.h"
 
 #include "base/logging.h"
+#include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
+#include "chrome/browser/intents/web_intents_registry_factory.h"
+#include "chrome/browser/intents/web_intents_registry.h"
+#include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
+#include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/toolbar/action_box_menu_model.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/browser/web_intents_dispatcher.h"
+#include "grit/generated_resources.h"
+#include "webkit/glue/web_intent_data.h"
+#include "webkit/glue/webkit_glue.h"
 
 namespace {
 
-// Extensions get command IDs that are beyond the maximal valid command ID
+// Share intents get command IDs that are beyond the maximal valid command ID
 // (0xDFFF) so that they are not confused with actual commands that appear in
-// the menu. For more details see: chrome/app/chrome_command_ids.h
-const int kFirstExtensionCommandId = 0xE000;
+// the menu. Extensions get a reserved block of commands after share handlers.
+// For more details see: chrome/app/chrome_command_ids.h
+const int kMaxShareItemsToShow = 20;  // TODO(skare): Show extras in submenu.
+enum ActionBoxLocalCommandIds {
+  IDC_CWS_FIND_SHARE_INTENTS = 0xE000,
+  IDC_ACTIONBOX_SHARE_FIRST,
+  IDC_ACTIONBOX_SHARE_LAST =
+      IDC_ACTIONBOX_SHARE_FIRST + kMaxShareItemsToShow - 1,
+  IDC_ACTIONBOX_EXTENSION_FIRST
+};
+
+const char kShareIntentAction[] = "http://webintents.org/share";
+const char kShareIntentMimeType[] = "text/uri-list";
 
 }  // namespace
 
 ActionBoxButtonController::ActionBoxButtonController(Browser* browser,
                                                      Delegate* delegate)
     : browser_(browser),
       delegate_(delegate),
-      next_extension_command_id_(kFirstExtensionCommandId) {
+      next_share_intent_command_id_(IDC_ACTIONBOX_SHARE_FIRST),
+      next_extension_command_id_(IDC_ACTIONBOX_EXTENSION_FIRST),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   DCHECK(browser_);
   DCHECK(delegate_);
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(browser->profile()));
 }
 
 ActionBoxButtonController::~ActionBoxButtonController() {}
 
 void ActionBoxButtonController::OnButtonClicked() {
-  // Creating the action box menu will populate it with the bookmark star etc,
-  // but no extensions.
-  scoped_ptr<ActionBoxMenuModel> menu_model(
-      new ActionBoxMenuModel(browser_, this));
-
-  // Add the extensions.
-  ExtensionService* extension_service =
-      extensions::ExtensionSystem::Get(browser_->profile())->
-          extension_service();
-  const extensions::ExtensionList& extensions =
-      extension_service->toolbar_model()->action_box_menu_items();
-  for (extensions::ExtensionList::const_iterator it = extensions.begin();
-       it != extensions.end(); ++it) {
-    menu_model->AddExtension(**it, GetCommandIdForExtension(**it));
-  }
-
-  delegate_->ShowMenu(menu_model.Pass());
+  // Request registered share intents; populate and show menu in the callback.
+  WebIntentsRegistry* intents_registry =
+      WebIntentsRegistryFactory::GetForProfile(browser_->profile());
+  intents_registry->GetIntentServices(
+      ASCIIToUTF16(kShareIntentAction),
+      ASCIIToUTF16(kShareIntentMimeType),
+      base::Bind(
+          &ActionBoxButtonController::OnWebIntentServicesAvailable,
+          weak_ptr_factory_.GetWeakPtr()));
 }
 
 bool ActionBoxButtonController::IsCommandIdChecked(int command_id) const {
   return false;
 }
 
 bool ActionBoxButtonController::IsCommandIdEnabled(int command_id) const {
   return true;
 }
 
 bool ActionBoxButtonController::GetAcceleratorForCommandId(
     int command_id,
     ui::Accelerator* accelerator) {
   return false;
 }
 
 void ActionBoxButtonController::ExecuteCommand(int command_id) {
-  // It might be a command associated with an extension.
+  // Handle explicit intent triggers for share intent commands.
+  if (share_intent_service_ids_.count(command_id) > 0) {
+    TriggerExplicitShareIntent(share_intent_service_ids_[command_id]);
+    return;
+  }
+
+  // Handle link to the CWS web store.
+  if (command_id == IDC_CWS_FIND_SHARE_INTENTS) {
+    NavigateToWebStoreShareIntentsList();
+    return;
+  }
+
+  // Handle commands associated with extensions.
   // Note that the extension might have been uninstalled or disabled while the
   // menu was open (sync perhaps?) but that will just fall through safely.
   const extensions::Extension* extension =
       GetExtensionForCommandId(command_id);
   if (extension) {
     // TODO(kalman): do something with the result.
     extensions::ExtensionSystem::Get(browser_->profile())->
         extension_service()->toolbar_model()->ExecuteBrowserAction(
             extension, browser_, NULL);
     return;
   }
 
+  // Otherwise, let the browser handle the command.
   chrome::ExecuteCommand(browser_, command_id);
 }
 
 int ActionBoxButtonController::GetCommandIdForExtension(
     const extensions::Extension& extension) {
   ExtensionIdCommandMap::iterator it =
       extension_command_ids_.find(extension.id());
   if (it != extension_command_ids_.end())
     return it->second;
   int command_id = next_extension_command_id_++;
@@ skipping 27 matching lines @@
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_UNLOADED);
   const extensions::Extension* extension =
       content::Details<extensions::UnloadedExtensionInfo>(details)->extension;
 
   // TODO(kalman): if there's a menu open, remove it from that too.
   // We may also want to listen to EXTENSION_LOADED to do the opposite.
   extension_command_ids_.erase(extension->id());
 }
+
+void ActionBoxButtonController::OnWebIntentServicesAvailable(
+    const std::vector<webkit_glue::WebIntentServiceData>& services) {
+  scoped_ptr<ActionBoxMenuModel> menu_model(
+      new ActionBoxMenuModel(browser_, this));
+
+  // Add Share intent items.
+  next_share_intent_command_id_ = IDC_ACTIONBOX_SHARE_FIRST;
+  share_intent_service_ids_.clear();
+  for (size_t i = 0; i < services.size(); ++i) {
+    int command_id = next_share_intent_command_id_++;
+    if (command_id > IDC_ACTIONBOX_SHARE_LAST) {
+      break;
+    }
+    share_intent_service_ids_[command_id] = services[i].service_url;
+    menu_model->AddItem(command_id, services[i].title);
+  }
+
+  // Add link to the Web Store to find additional share intents.
+  menu_model->AddItemWithStringId(IDC_CWS_FIND_SHARE_INTENTS,
+      IDS_FIND_SHARE_INTENTS);
+
+  // Add Extensions.
+  next_extension_command_id_ = IDC_ACTIONBOX_EXTENSION_FIRST;
+  extension_command_ids_.clear();
+  ExtensionService* extension_service =
+      extensions::ExtensionSystem::Get(browser_->profile())->
+          extension_service();
+  const extensions::ExtensionList& extensions =
+      extension_service->toolbar_model()->action_box_menu_items();
+  for (extensions::ExtensionList::const_iterator it = extensions.begin();
+       it != extensions.end(); ++it) {
+    menu_model->AddExtension(**it, GetCommandIdForExtension(**it));
+  }
+
+  // And show the menu.
+  delegate_->ShowMenu(menu_model.Pass());
+}
+
+void ActionBoxButtonController::TriggerExplicitShareIntent(
+    const GURL& share_service_url) {
+  const GURL& current_url = chrome::GetActiveWebContents(browser_)->GetURL();
+  webkit_glue::WebIntentData intent_data(
+      ASCIIToUTF16(kShareIntentAction),
+      ASCIIToUTF16(kShareIntentMimeType),
+      UTF8ToUTF16(current_url.spec()));
+  intent_data.service = share_service_url;
+  scoped_ptr<content::WebIntentsDispatcher> dispatcher(
+      content::WebIntentsDispatcher::Create(intent_data));
+  static_cast<content::WebContentsDelegate*>(browser_)->

[Greg Billock, 2012/10/12 18:41:50]

The new API for you is now checked in. You can call

TabContents::web_intents_picker_controller()->SetDispatcher(dispatcher.release());

pickerController->InvokeServiceWithSelection(menu_model.selected_service())

I think you have a tab contents available from your update from the location
bar, and the picker controller is available from there.

[skare_, 2012/10/12 23:42:51]

Thanks! I made this change in a local git branch and uploaded to 
http://codereview.chromium.org/11150005/
to minimize churn in this cl.

should there be user-visible differences with the new API?
I see the same behavior as the existing approach as the intent picker launches
and loads an inline intent.

+      WebIntentDispatch(NULL, dispatcher.release());
+}
+
+void ActionBoxButtonController::NavigateToWebStoreShareIntentsList() {
+  GURL query_url = extension_urls::GetWebstoreIntentQueryURL(
+      "http://webintents.org/share",
+      "text/uri-list");
+  chrome::NavigateParams params(browser_->profile(), query_url,
+                                content::PAGE_TRANSITION_LINK);
+  params.disposition = NEW_FOREGROUND_TAB;
+  chrome::Navigate(&params);
+}