Use the DefaultSearchManager as the exclusive authority on DSE, ignoring Web Data.

chrome/browser/search_engines/search_provider_install_data.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/search_engines/search_provider_install_data.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/sequenced_task_runner_helpers.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_url_tracker.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/search_host_to_urls_map.h"
 #include "chrome/browser/search_engines/search_terms_data.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
+#include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/search_engines/util.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_process_host_observer.h"
 
 using content::BrowserThread;
 
 typedef SearchHostToURLsMap::TemplateURLSet TemplateURLSet;
 
 namespace {
 
+void LoadDataOnUIThread(TemplateURLService* template_url_service,
+                        const base::Callback<void(ScopedVector<TemplateURL>,
+                                                  TemplateURL*)>& callback) {
+  ScopedVector<TemplateURL> template_url_copies;
+  TemplateURL* default_provider_copy = NULL;
+  TemplateURLService::TemplateURLVector original_template_urls =
+      template_url_service->GetTemplateURLs();
+  TemplateURL* original_default_provider =
+      template_url_service->GetDefaultSearchProvider();
+  for (TemplateURLService::TemplateURLVector::const_iterator it =
+           original_template_urls.begin();
+       it != original_template_urls.end();
+       ++it) {
+    template_url_copies.push_back(new TemplateURL(NULL, (*it)->data()));
+    if (*it == original_default_provider)
+      default_provider_copy = template_url_copies.back();
+  }
+  BrowserThread::PostTask(BrowserThread::IO,
+                          FROM_HERE,
+                          base::Bind(callback,
+                                     base::Passed(template_url_copies.Pass()),
+                                     base::Unretained(default_provider_copy)));
+}
+
 // Implementation of SearchTermsData that may be used on the I/O thread.
 class IOThreadSearchTermsData : public SearchTermsData {
  public:
   explicit IOThreadSearchTermsData(const std::string& google_base_url);
 
   // Implementation of SearchTermsData.
   virtual std::string GoogleBaseURLValue() const OVERRIDE;
 
  private:
   std::string google_base_url_;
@@ skipping 109 matching lines @@
   DCHECK(requested_origin == requested_origin.GetOrigin());
   DCHECK(template_url->GetType() != TemplateURL::OMNIBOX_API_EXTENSION);
   return requested_origin ==
       TemplateURLService::GenerateSearchURLUsingTermsData(template_url,
           search_terms_data).GetOrigin();
 }
 
 }  // namespace
 
 SearchProviderInstallData::SearchProviderInstallData(
-    Profile* profile, content::RenderProcessHost* host)
-    : web_service_(WebDataService::FromBrowserContext(profile)),
-      load_handle_(0),
+    Profile* profile,
+    content::RenderProcessHost* host)
+    : template_url_service_(TemplateURLServiceFactory::GetForProfile(profile)),
       google_base_url_(UIThreadSearchTermsData(profile).GoogleBaseURLValue()),
       weak_factory_(this) {
   // GoogleURLObserver is responsible for killing itself when
   // the given notification occurs.
   new GoogleURLObserver(profile,
                         new GoogleURLChangeNotifier(weak_factory_.GetWeakPtr()),
                         host);
 }
 
 SearchProviderInstallData::~SearchProviderInstallData() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-
-  if (load_handle_) {
-    DCHECK(web_service_.get());
-    web_service_->CancelRequest(load_handle_);
-  }
 }
 
 void SearchProviderInstallData::CallWhenLoaded(const base::Closure& closure) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (provider_map_.get()) {
     closure.Run();
     return;
   }
 
+  bool do_load = closure_queue_.empty();
   closure_queue_.push_back(closure);
-  if (load_handle_)
+
+  // If the queue wasn't empty, there was already a load in progress.
+  if (!do_load)
     return;
 
-  if (web_service_.get())
-    load_handle_ = web_service_->GetKeywords(this);
-  else
+  if (template_url_service_) {
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&LoadDataOnUIThread,
+                   template_url_service_,
+                   base::Bind(&SearchProviderInstallData::OnTemplateURLsLoaded,
+                              weak_factory_.GetWeakPtr())));
+  } else {
     OnLoadFailed();
+  }
 }
 
 SearchProviderInstallData::State SearchProviderInstallData::GetInstallState(
     const GURL& requested_origin) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(provider_map_.get());
 
   // First check to see if the origin is the default search provider.
   if (requested_origin.spec() == default_search_origin_)
     return INSTALLED_AS_DEFAULT;
@@ skipping 11 matching lines @@
       return INSTALLED_BUT_NOT_DEFAULT;
   }
   return NOT_INSTALLED;
 }
 
 void SearchProviderInstallData::OnGoogleURLChange(
     const std::string& google_base_url) {
   google_base_url_ = google_base_url;
 }
 
-void SearchProviderInstallData::OnWebDataServiceRequestDone(
-    WebDataService::Handle h,
-    const WDTypedResult* result) {
+void SearchProviderInstallData::OnTemplateURLsLoaded(
+    ScopedVector<TemplateURL> template_urls,
+    TemplateURL* default_provider) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
-  // Reset the load_handle so that we don't try and cancel the load in
-  // the destructor.
-  load_handle_ = 0;
+  template_urls_ = template_urls.Pass();
 
-  if (!result) {
-    // Results are null if the database went away or (most likely) wasn't
-    // loaded.
-    OnLoadFailed();
-    return;
-  }
-
-  TemplateURL* default_search_provider = NULL;
-  int new_resource_keyword_version = 0;
-  std::vector<TemplateURL*> extracted_template_urls;
-  GetSearchProvidersUsingKeywordResult(*result, NULL, NULL,
-      &extracted_template_urls, &default_search_provider,
-      &new_resource_keyword_version, NULL);
-  template_urls_.get().insert(template_urls_.get().begin(),
-                              extracted_template_urls.begin(),
-                              extracted_template_urls.end());
   IOThreadSearchTermsData search_terms_data(google_base_url_);
   provider_map_.reset(new SearchHostToURLsMap());
   provider_map_->Init(template_urls_.get(), search_terms_data);
-  SetDefault(default_search_provider);
+  SetDefault(default_provider);
   NotifyLoaded();
 }
 
 void SearchProviderInstallData::SetDefault(const TemplateURL* template_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!template_url) {
     default_search_origin_.clear();
     return;
   }
@@ skipping 28 matching lines @@
 
   std::for_each(closure_queue.begin(),
                 closure_queue.end(),
                 std::mem_fun_ref(&base::Closure::Run));
 
   // Since we expect this request to be rare, clear out the information. This
   // also keeps the responses current as the search providers change.
   provider_map_.reset();
   SetDefault(NULL);
 }