[Web Intents] Inline installation of extensions in web intents picker.

chrome/browser/intents/web_intents_registry.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/intents/web_intents_registry.h"
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/intents/default_web_intent_service.h"
 #include "chrome/browser/webdata/web_data_service.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_set.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/mime_util.h"
 
 namespace {
 
+typedef WebIntentsRegistry::IntentServiceList IntentServiceList;
+
 // Compares two mime types for equality. Supports wild cards in both
 // |type1| and |type2|. Wild cards are of the form '<type>/*' or '*'.
 bool MimeTypesAreEqual(const string16& type1, const string16& type2) {
   // We don't have a MIME matcher that allows patterns on both sides
   // Instead, we do two comparisons, treating each type in turn as a
   // pattern. If either one matches, we consider this a MIME match.
   if (net::MatchesMimeType(UTF16ToUTF8(type1), UTF16ToUTF8(type2)))
     return true;
   return net::MatchesMimeType(UTF16ToUTF8(type2), UTF16ToUTF8(type1));
 }
 
+// Adds any intent services of |extension| that match |action| to
+// |matching_services|.
+void AddMatchingServicesForExtension(const Extension& extension,
+                                     const string16& action,
+                                     IntentServiceList* matching_services) {
+  const IntentServiceList& services = extension.intents_services();
+  for (IntentServiceList::const_iterator i = services.begin();
+       i != services.end(); ++i) {
+    if (action.empty() || action == i->action)
+      matching_services->push_back(*i);
+  }
+}
+
+// Removes all services from |matching_services| that do not match |mimetype|.
+// Wildcards are supported, of the form '<type>/*' or '*'.
+void FilterServicesByMimetype(const string16& mimetype,
+                              IntentServiceList* matching_services) {
+  // Filter out all services not matching the query type.
+  IntentServiceList::iterator iter(matching_services->begin());
+  while (iter != matching_services->end()) {
+    if (MimeTypesAreEqual(iter->type, mimetype))
+      ++iter;
+    else
+      iter = matching_services->erase(iter);
+  }
+}
+
 }  // namespace
 
 using webkit_glue::WebIntentServiceData;
 
 // Internal object representing all data associated with a single query.
 struct WebIntentsRegistry::IntentsQuery {
   // Unique query identifier.
   QueryID query_id_;
 
   // Underlying data query.
@@ skipping 66 matching lines @@
   IntentServiceList matching_services = static_cast<
       const WDResult<IntentServiceList>*>(result)->GetValue();
 
   // Loop over all services in all extensions, collect ones
   // matching the query.
   if (extension_service_) {
     const ExtensionSet* extensions = extension_service_->extensions();
     if (extensions) {
       for (ExtensionSet::const_iterator i(extensions->begin());
            i != extensions->end(); ++i) {
-        const IntentServiceList& services((*i)->intents_services());
-        for (IntentServiceList::const_iterator j(services.begin());
-             j != services.end(); ++j) {
-          if (query->action_.empty() || query->action_ == j->action)
-            matching_services.push_back(*j);
-        }
+        AddMatchingServicesForExtension(**i, query->action_,
+                                        &matching_services);
       }
     }
   }
 
   // Filter out all services not matching the query type.
-  IntentServiceList::iterator iter(matching_services.begin());
-  while (iter != matching_services.end()) {
-    if (MimeTypesAreEqual(iter->type, query->type_))
-      ++iter;
-    else
-      iter = matching_services.erase(iter);
-  }
+  FilterServicesByMimetype(query->type_, &matching_services);
 
   query->consumer_->OnIntentsQueryDone(query->query_id_, matching_services);
   delete query;
 }
 
 const Extension* WebIntentsRegistry::ExtensionForURL(const std::string& url) {
   const ExtensionSet* extensions = extension_service_->extensions();
   if (!extensions)
     return NULL;
 
@@ skipping 120 matching lines @@
     const base::Callback<void(bool)>& callback) {
   IntentsQuery* query = new IntentsQuery(
       next_query_id_++, new ServiceCheckConsumer(service, callback));
   query->pending_query_ = wds_->GetWebIntentServicesForURL(
       UTF8ToUTF16(service.service_url.spec()), this);
   queries_[query->pending_query_] = query;
 
   return query->query_id_;
 }
 
+WebIntentsRegistry::QueryID
+    WebIntentsRegistry::GetIntentServicesForExtensionFilter(
+        const string16& action,
+        const string16& mimetype,
+        const std::string& extension_id,
+        Consumer* consumer) {
+  DCHECK(consumer);
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  scoped_ptr<IntentsQuery> query(
+      new IntentsQuery(next_query_id_++, consumer, action, mimetype));
+  int query_id = query->query_id_;
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&WebIntentsRegistry::DoGetIntentServicesForExtensionFilter,
+                 base::Unretained(this),
+                 base::Passed(&query), extension_id));
+
+  return query_id;
+}
+
+void WebIntentsRegistry::DoGetIntentServicesForExtensionFilter(
+    scoped_ptr<IntentsQuery> query,
+    const std::string& extension_id) {
+  IntentServiceList matching_services;
+
+  if (extension_service_) {
+    const Extension* extension =
+        extension_service_->GetExtensionById(extension_id, false);
+    AddMatchingServicesForExtension(*extension,
+                                    query->action_,
+                                    &matching_services);
+    FilterServicesByMimetype(query->type_, &matching_services);
+  }
+
+  query->consumer_->OnIntentsQueryDone(query->query_id_, matching_services);
+}
+
 void WebIntentsRegistry::RegisterDefaultIntentService(
     const DefaultWebIntentService& default_service) {
   DCHECK(wds_.get());
   wds_->AddDefaultWebIntentService(default_service);
 }
 
 void WebIntentsRegistry::UnregisterDefaultIntentService(
     const DefaultWebIntentService& default_service) {
   DCHECK(wds_.get());
   wds_->RemoveDefaultWebIntentService(default_service);
@@ skipping 17 matching lines @@
     const WebIntentServiceData& service) {
   DCHECK(wds_.get());
   wds_->AddWebIntentService(service);
 }
 
 void WebIntentsRegistry::UnregisterIntentService(
     const WebIntentServiceData& service) {
   DCHECK(wds_.get());
   wds_->RemoveWebIntentService(service);
 }