Use IntentsQuery as the WDS consumer. By unencumbering WebIntentsRegistry of this responsibility we…

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 <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 66 matching lines @@
                                      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|.
+// Removes all services from |matching_services| that do not match |type|.
 // Wildcards are supported, of the form '<type>/*' or '*'.
-void FilterServicesByMimetype(const string16& mimetype,
-                              IntentServiceList* matching_services) {
+void FilterServicesByType(const string16& type,
+                          IntentServiceList* matching_services) {
   // Filter out all services not matching the query type.
   IntentServiceList::iterator iter(matching_services->begin());
   while (iter != matching_services->end()) {
-    if (WebIntentsTypesMatch(iter->type, mimetype))
+    if (WebIntentsTypesMatch(iter->type, type))
       ++iter;
     else
       iter = matching_services->erase(iter);
   }
 }
 
 // Callback for existence checks. Converts a callback for a list of services
 // into a callback that returns true if the list contains a specific service.
 void ExistenceCallback(const webkit_glue::WebIntentServiceData& service,
                        const base::Callback<void(bool)>& callback,
@@ skipping 39 matching lines @@
       (lhs.action != rhs.action) ||
       (lhs.title != rhs.title) ||
       (lhs.disposition != rhs.disposition));
 }
 
 }  // namespace
 
 using webkit_glue::WebIntentServiceData;
 
 // Internal object representing all data associated with a single query.
-struct WebIntentsRegistry::IntentsQuery {
+struct WebIntentsRegistry::IntentsQuery : public WebDataServiceConsumer {
+
+  // Handle so we can call back into the WebIntentsRegistry when
+  // processing query results. The registry is guaranteed to be
+  // valid for the life of this object. We do not own this object.
+  WebIntentsRegistry* registry_;
+
   // Underlying data query.
-  WebDataService::Handle pending_query_;
+  WebDataService::Handle query_handle_;
 
   // The callback for this particular query.
   QueryCallback callback_;
 
   // Callback for a query for defaults.
   DefaultQueryCallback default_callback_;
 
   // The particular action to filter for while searching through extensions.
   // If |action_| is empty, return all extension-provided services.
   string16 action_;
 
   // The MIME type that was requested for this service query.
   // Suppports wild cards.
   string16 type_;
 
   // The url of the invoking page.
   GURL url_;
 
   // Create a new IntentsQuery for services with the specified action/type.
-  IntentsQuery(const QueryCallback& callback,
+  IntentsQuery(WebIntentsRegistry* registry,
+               const QueryCallback& callback,
                const string16& action, const string16& type)
-      : callback_(callback), action_(action), type_(type) {}
+      : registry_(registry), callback_(callback), action_(action),
+        type_(type) {}
 
   // Create a new IntentsQuery for all intent services or for existence checks.
-  explicit IntentsQuery(const QueryCallback callback)
-      : callback_(callback), type_(ASCIIToUTF16("*")) {}
+  IntentsQuery(WebIntentsRegistry* registry,
+               const QueryCallback callback)
+      : registry_(registry), callback_(callback), type_(ASCIIToUTF16("*")) {}
 
   // Create a new IntentsQuery for default services.
-  IntentsQuery(const DefaultQueryCallback& callback,
+  IntentsQuery(WebIntentsRegistry* registry,
+               const DefaultQueryCallback& callback,
                const string16& action, const string16& type, const GURL& url)
-      : default_callback_(callback), action_(action), type_(type), url_(url) {}
+      : registry_(registry), default_callback_(callback), action_(action),
+        type_(type), url_(url) {}
+
+  void OnWebDataServiceRequestDone(
+      WebDataService::Handle h,
+      const WDTypedResult* result) OVERRIDE {
+
+    // dispatch the request
+    if (result->GetType() == WEB_INTENTS_RESULT) {
+      registry_->OnWebIntentsResultReceived(this, result);
+    } else if (result->GetType() == WEB_INTENTS_DEFAULTS_RESULT) {
+      registry_->OnWebIntentsDefaultsResultReceived(this, result);
+    } else {
+      NOTREACHED();
+    }
+  }
 };
 
 WebIntentsRegistry::WebIntentsRegistry() {}
 
 WebIntentsRegistry::~WebIntentsRegistry() {
+
   // Cancel all pending queries, since we can't handle them any more.
-  for (QueryMap::iterator it(queries_.begin()); it != queries_.end(); ++it) {
-    wds_->CancelRequest(it->first);
-    delete it->second;
+  for (QueryVector::iterator it = pending_queries_.begin();
+      it != pending_queries_.end(); ++it) {
+    IntentsQuery* query = *it;
+    wds_->CancelRequest(query->query_handle_);
+    delete query;
   }
 }
 
 void WebIntentsRegistry::Initialize(
     scoped_refptr<WebDataService> wds,
     ExtensionServiceInterface* extension_service) {
   wds_ = wds;
   extension_service_ = extension_service;
 }
 
-void WebIntentsRegistry::OnWebDataServiceRequestDone(
-    WebDataService::Handle h,
+void WebIntentsRegistry::OnWebIntentsResultReceived(
+    IntentsQuery* query,
     const WDTypedResult* result) {
+  DCHECK(query);
   DCHECK(result);
-  if (result->GetType() == WEB_INTENTS_DEFAULTS_RESULT) {
-    OnWebDataServiceDefaultsRequestDone(h, result);
-    return;
-  }
   DCHECK(result->GetType() == WEB_INTENTS_RESULT);
 
-  QueryMap::iterator it = queries_.find(h);
-  DCHECK(it != queries_.end());
-
-  IntentsQuery* query(it->second);
-  DCHECK(query);
-  queries_.erase(it);
+  bool query_found = ClaimQuery(query);
+  DCHECK(query_found);
 
   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) {
         AddMatchingServicesForExtension(**i, query->action_,
                                         &matching_services);
       }
     }
   }
 
   // Filter out all services not matching the query type.
-  FilterServicesByMimetype(query->type_, &matching_services);
+  FilterServicesByType(query->type_, &matching_services);
 
   // Collapse intents that are equivalent for all but |type|.
   CollapseIntents(&matching_services);
 
   query->callback_.Run(matching_services);
   delete query;
 }
 
-const Extension* WebIntentsRegistry::ExtensionForURL(const std::string& url) {
-  const ExtensionSet* extensions = extension_service_->extensions();
-  if (!extensions)
-    return NULL;
+void WebIntentsRegistry::OnWebIntentsDefaultsResultReceived(
+    IntentsQuery* query,
+    const WDTypedResult* result) {
+  DCHECK(query);
+  DCHECK(result);
+  DCHECK(result->GetType() == WEB_INTENTS_DEFAULTS_RESULT);
 
-  // Use the unsafe ExtensionURLInfo constructor: we don't care if the extension
-  // is running or not.
-  GURL gurl(url);
-  ExtensionURLInfo info(gurl);
-  return extensions->GetExtensionOrAppByURL(info);
-}
-
-void WebIntentsRegistry::OnWebDataServiceDefaultsRequestDone(
-    WebDataService::Handle h,
-    const WDTypedResult* result) {
-  QueryMap::iterator it = queries_.find(h);
-  DCHECK(it != queries_.end());
-
-  IntentsQuery* query(it->second);
-  DCHECK(query);
-  queries_.erase(it);
+  bool query_found = ClaimQuery(query);
+  DCHECK(query_found);
 
   std::vector<DefaultWebIntentService> services = static_cast<
       const WDResult<std::vector<DefaultWebIntentService> >*>(result)->
           GetValue();
 
   DefaultWebIntentService default_service;
   std::vector<DefaultWebIntentService>::iterator iter(services.begin());
   for (; iter != services.end(); ++iter) {
     if (!WebIntentsTypesMatch(iter->type, query->type_)) {
       continue;
@@ skipping 37 matching lines @@
         break;
       }
     }
   }
 
   query->default_callback_.Run(default_service);
   delete query;
 }
 
 void WebIntentsRegistry::GetIntentServices(
-    const string16& action, const string16& mimetype,
+    const string16& action, const string16& type,
     const QueryCallback& callback) {
   DCHECK(wds_.get());
   DCHECK(!callback.is_null());
 
-  IntentsQuery* query = new IntentsQuery(callback, action, mimetype);
-  query->pending_query_ = wds_->GetWebIntentServices(action, this);
-  queries_[query->pending_query_] = query;
+  IntentsQuery* query = new IntentsQuery(this, callback, action, type);
+  query->query_handle_ = wds_->GetWebIntentServices(action, query);
+  TrackQuery(query);
 }
 
 void WebIntentsRegistry::GetAllIntentServices(
     const QueryCallback& callback) {
   DCHECK(wds_.get());
   DCHECK(!callback.is_null());
 
-  IntentsQuery* query = new IntentsQuery(callback);
-  query->pending_query_ = wds_->GetAllWebIntentServices(this);
-  queries_[query->pending_query_] = query;
+  IntentsQuery* query = new IntentsQuery(this, callback);
+  query->query_handle_ = wds_->GetAllWebIntentServices(query);
+  TrackQuery(query);
 }
 
 void WebIntentsRegistry::IntentServiceExists(
     const WebIntentServiceData& service,
     const base::Callback<void(bool)>& callback) {
   DCHECK(!callback.is_null());
 
   IntentsQuery* query = new IntentsQuery(
-      base::Bind(&ExistenceCallback, service, callback));
-  query->pending_query_ = wds_->GetWebIntentServicesForURL(
-      UTF8ToUTF16(service.service_url.spec()), this);
-  queries_[query->pending_query_] = query;
+      this, base::Bind(&ExistenceCallback, service, callback));
+  query->query_handle_ = wds_->GetWebIntentServicesForURL(
+      UTF8ToUTF16(service.service_url.spec()), query);
+  TrackQuery(query);
 }
 
 void WebIntentsRegistry::GetIntentServicesForExtensionFilter(
         const string16& action,
-        const string16& mimetype,
+        const string16& type,
         const std::string& extension_id,
         const QueryCallback& callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(!callback.is_null());
 
+  // This isn't a WDS query, so we don't track it,
+  // or claim the query later.
   scoped_ptr<IntentsQuery> query(
-      new IntentsQuery(callback, action, mimetype));
+      new IntentsQuery(this, callback, action, type));
   content::BrowserThread::PostTask(
       content::BrowserThread::UI,
       FROM_HERE,
       base::Bind(&WebIntentsRegistry::DoGetIntentServicesForExtensionFilter,
                  base::Unretained(this),
                  base::Passed(&query), extension_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);
+    FilterServicesByType(query->type_, &matching_services);
   }
 
   query->callback_.Run(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);
 }
 
 void WebIntentsRegistry::GetDefaultIntentService(
     const string16& action,
     const string16& type,
     const GURL& invoking_url,
     const DefaultQueryCallback& callback) {
   DCHECK(!callback.is_null());
 
   IntentsQuery* query =
-      new IntentsQuery(callback, action, type, invoking_url);
-  query->pending_query_ =
-      wds_->GetDefaultWebIntentServicesForAction(action, this);
-  queries_[query->pending_query_] = query;
+      new IntentsQuery(this, callback, action, type, invoking_url);
+  query->query_handle_ =
+      wds_->GetDefaultWebIntentServicesForAction(action, query);
+  TrackQuery(query);
 }
 
 void WebIntentsRegistry::RegisterIntentService(
     const WebIntentServiceData& service) {
   DCHECK(wds_.get());
   wds_->AddWebIntentService(service);
 }
 
 void WebIntentsRegistry::UnregisterIntentService(
     const WebIntentServiceData& service) {
@@ skipping 24 matching lines @@
       if (write_iter != read_iter)
         *write_iter = *read_iter;
     }
     ++read_iter;
   }
 
   // Cut off everything after the last intent copied to the list.
   if (++write_iter != services->end())
     services->erase(write_iter, services->end());
 }
+
+const Extension* WebIntentsRegistry::ExtensionForURL(const std::string& url) {
+  const ExtensionSet* extensions = extension_service_->extensions();
+  if (!extensions)
+    return NULL;
+
+  // Use the unsafe ExtensionURLInfo constructor: we don't care if the extension
+  // is running or not.
+  GURL gurl(url);
+  ExtensionURLInfo info(gurl);
+  return extensions->GetExtensionOrAppByURL(info);
+}
+
+void WebIntentsRegistry::TrackQuery(IntentsQuery* query) {
+  DCHECK(query);
+  pending_queries_.push_back(query);
+}
+
+bool WebIntentsRegistry::ClaimQuery(IntentsQuery* query) {
+  DCHECK(query);
+  QueryVector::iterator it = std::find(

[groby-ooo-7-16, 2012/07/27 01:17:04]

standard C++ idiom for this:

std::erase(std::remove(pending_queries.begin(), pending_queries.end(), query),
pending_queries_.end() )

Since you want to ensure we only claim existing queries, you might want
DCHECK(std::count(pending_queries_.begin(), pending_queries_.end(), query);

And if that's too much STL tomfoolery, at least move the DCHECK into Claim -
it's part of the contract.

+      pending_queries_.begin(), pending_queries_.end(), query);
+  if (it != pending_queries_.end()) {
+    pending_queries_.erase(it);
+    return true;
+  } else {
+    return false;
+  }
+}