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 {
+  kCWSFindShareIntentsCommandId = 0xE000,

[sky, 2012/10/11 23:36:25]

Enums use ALL_CAPS style.

[skare_, 2012/10/12 01:02:06]

Done.
Switched to IDC_* names for command ids even though they're local. I am more
familiar with another google client project; please let me know if that prefix
is reserved for higher-level command identifiers.

[sky, 2012/10/12 14:33:25]

Don't do that, it's easy to misread when using IDC_.

[skare_, 2012/10/12 20:21:07]

Done.

+  kFirstShareIntentCommandId,
+  kLastShareIntentCommandId =
+      kFirstShareIntentCommandId + kMaxShareItemsToShow - 1,
+  kFirstExtensionCommandId
+};
+
+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_(kFirstShareIntentCommandId),
+      next_extension_command_id_(kFirstExtensionCommandId),
+      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() {}
+ActionBoxButtonController::~ActionBoxButtonController() {
+  weak_ptr_factory_.InvalidateWeakPtrs();

[sky, 2012/10/11 23:36:25]

Isn't this done for you by the destructor of WeakPtrFactory?

[skare_, 2012/10/12 01:02:06]

Done.

+}
 
 void ActionBoxButtonController::OnButtonClicked() {
-  // Creating the action box menu will populate it with the bookmark star etc,
-  // but no extensions.
+  // 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()));
+}
+
+void ActionBoxButtonController::OnWebIntentServicesAvailable(
+    const std::vector<webkit_glue::WebIntentServiceData>& services) {
   scoped_ptr<ActionBoxMenuModel> menu_model(
       new ActionBoxMenuModel(browser_, this));
 
-  // Add the extensions.
+  // Add Share intent items.
+  next_share_intent_command_id_ = kFirstShareIntentCommandId;
+  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 > kLastShareIntentCommandId) {
+      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(kCWSFindShareIntentsCommandId,
+      IDS_FIND_SHARE_INTENTS);
+
+  // Add Extensions.
+  next_extension_command_id_ = kFirstExtensionCommandId;
+  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.

[sky, 2012/10/11 23:36:25]

How do you know how long it takes to get the services? Might the user have
clicked else where?

[skare_, 2012/10/12 01:02:06]

is the pattern to watch for closed and then cancel the action?

Alternatively we could enumerate extensions on controller startup (since it's
longer-lived than the menu) and watch for new ones.

[sky, 2012/10/12 14:33:25]

I don't know that there is anything you could look for.
That would make the menu instant, which I like. Are there any down sides? Would
it slow down startup at all?

[skare_, 2012/10/12 20:21:07]

Resolved -- in the latest revision the population is synchronous again (intents
provides as synchronous service check if you lookup per-extension). The menu
shows up immediately again.

In case that doesn't work, the asynch population would be fast. My concern there
is that it places some load, however small, on all users during startup and
whenever extensions are loaded or unloaded. The synchronous approach will only
query the intent registry if users open the action box.

   delegate_->ShowMenu(menu_model.Pass());
 }
 
 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 == kCWSFindShareIntentsCommandId) {
+    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::NavigateToWebStoreShareIntentsList() {

[sky, 2012/10/11 23:36:25]

make order match header.

[skare_, 2012/10/12 01:02:06]

Done.

+  Profile* profile = Profile::FromBrowserContext(

[sky, 2012/10/11 23:36:25]

browser_->profile()

[skare_, 2012/10/12 01:02:06]

done and inlined below, thanks.

+      chrome::GetActiveWebContents(browser_)->GetBrowserContext());
+  if (!profile)

[sky, 2012/10/11 23:36:25]

Remove this.

[skare_, 2012/10/12 01:02:06]

Done.

+    return;
+  GURL query_url = extension_urls::GetWebstoreIntentQueryURL(
+      "http://webintents.org/share",
+      "text/uri-list");
+
+  chrome::NavigateParams params(profile, query_url,
+                                content::PAGE_TRANSITION_LINK);
+  params.disposition = NEW_FOREGROUND_TAB;
+  chrome::Navigate(&params);
+}
+
+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_)->
+      WebIntentDispatch(NULL, dispatcher.release());
+}