No content dependencies in TemplateURLFetcher

chrome/browser/search_engines/template_url_fetcher.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 "build/build_config.h"
 
 #include "chrome/browser/search_engines/template_url_fetcher.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/search_engines/template_url_parser.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_service.h"
-#include "content/public/browser/render_frame_host.h"
-#include "content/public/browser/render_process_host.h"
-#include "content/public/browser/web_contents.h"
-#include "content/public/common/url_fetcher.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 // RequestDelegate ------------------------------------------------------------
 class TemplateURLFetcher::RequestDelegate : public net::URLFetcherDelegate {
  public:
-  // Takes ownership of |callbacks|.
-  RequestDelegate(TemplateURLFetcher* fetcher,
-                  const base::string16& keyword,
-                  const GURL& osdd_url,
-                  const GURL& favicon_url,
-                  content::WebContents* web_contents,
-                  const ConfirmAddSearchProviderCallback& callback,
-                  ProviderType provider_type);
+  RequestDelegate(
+      TemplateURLFetcher* fetcher,
+      const base::string16& keyword,
+      const GURL& osdd_url,
+      const GURL& favicon_url,
+      const URLFetcherCustomizeCallback& url_fetcher_customize_callback,
+      const ConfirmAddSearchProviderCallback& confirm_add_callback,
+      ProviderType provider_type);
 
   // net::URLFetcherDelegate:
   // If data contains a valid OSDD, a TemplateURL is created and added to
   // the TemplateURLService.
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
   // URL of the OSDD.
   GURL url() const { return osdd_url_; }
 
   // Keyword to use.
   base::string16 keyword() const { return keyword_; }
 
   // The type of search provider being fetched.
   ProviderType provider_type() const { return provider_type_; }
 
  private:
   void OnLoaded();
   void AddSearchProvider();
 
   scoped_ptr<net::URLFetcher> url_fetcher_;
   TemplateURLFetcher* fetcher_;
   scoped_ptr<TemplateURL> template_url_;
   base::string16 keyword_;
   const GURL osdd_url_;
   const GURL favicon_url_;
   const ProviderType provider_type_;
-  ConfirmAddSearchProviderCallback callback_;
+  ConfirmAddSearchProviderCallback confirm_add_callback_;
 
   scoped_ptr<TemplateURLService::Subscription> template_url_subscription_;
 
   DISALLOW_COPY_AND_ASSIGN(RequestDelegate);
 };
 
 TemplateURLFetcher::RequestDelegate::RequestDelegate(
     TemplateURLFetcher* fetcher,
     const base::string16& keyword,
     const GURL& osdd_url,
     const GURL& favicon_url,
-    content::WebContents* web_contents,
-    const ConfirmAddSearchProviderCallback& callback,
+    const URLFetcherCustomizeCallback& url_fetcher_customize_callback,
+    const ConfirmAddSearchProviderCallback& confirm_add_callback,
     ProviderType provider_type)
     : url_fetcher_(net::URLFetcher::Create(
           osdd_url, net::URLFetcher::GET, this)),
       fetcher_(fetcher),
       keyword_(keyword),
       osdd_url_(osdd_url),
       favicon_url_(favicon_url),
       provider_type_(provider_type),
-      callback_(callback) {
+      confirm_add_callback_(confirm_add_callback) {
   TemplateURLService* model = fetcher_->template_url_service_;
   DCHECK(model);  // TemplateURLFetcher::ScheduleDownload verifies this.
 
   if (!model->loaded()) {
     // Start the model load and set-up waiting for it.
     template_url_subscription_ = model->RegisterOnLoadedCallback(
         base::Bind(&TemplateURLFetcher::RequestDelegate::OnLoaded,
                    base::Unretained(this)));
     model->Load();
   }
 
+  if (!url_fetcher_customize_callback.is_null())
+    url_fetcher_customize_callback.Run(url_fetcher_.get());
+
   url_fetcher_->SetRequestContext(fetcher->request_context_.get());
-  // Can be NULL during tests.
-  if (web_contents) {
-    content::AssociateURLFetcherWithRenderFrame(
-        url_fetcher_.get(),
-        web_contents->GetURL(),
-        web_contents->GetRenderProcessHost()->GetID(),
-        web_contents->GetMainFrame()->GetRoutingID());
-  }
-
   url_fetcher_->Start();
 }
 
 void TemplateURLFetcher::RequestDelegate::OnLoaded() {
   template_url_subscription_.reset();
   if (!template_url_.get())
     return;
   AddSearchProvider();
   // WARNING: AddSearchProvider deletes us.
 }
@@ skipping 78 matching lines @@
       model->Add(new TemplateURL(data));
       break;
 
     case EXPLICIT_PROVIDER:
       // Confirm addition and allow user to edit default choices. It's ironic
       // that only *non*-autodetected additions get confirmed, but the user
       // expects feedback that his action did something.
       // The source WebContents' delegate takes care of adding the URL to the
       // model, which takes ownership, or of deleting it if the add is
       // cancelled.
-      callback_.Run(make_scoped_ptr(new TemplateURL(data)));
+      confirm_add_callback_.Run(make_scoped_ptr(new TemplateURL(data)));
       break;
 
     default:
       NOTREACHED();
       break;
   }
 
   fetcher_->RequestCompleted(this);
   // WARNING: RequestCompleted deletes us.
 }
 
 // TemplateURLFetcher ---------------------------------------------------------
 
 TemplateURLFetcher::TemplateURLFetcher(
     TemplateURLService* template_url_service,
     net::URLRequestContextGetter* request_context)
     : template_url_service_(template_url_service),
       request_context_(request_context) {
 }
 
 TemplateURLFetcher::~TemplateURLFetcher() {
 }
 
 void TemplateURLFetcher::ScheduleDownload(
     const base::string16& keyword,
     const GURL& osdd_url,
     const GURL& favicon_url,
-    content::WebContents* web_contents,
-    const ConfirmAddSearchProviderCallback& callback,
+    const URLFetcherCustomizeCallback& url_fetcher_customize_callback,
+    const ConfirmAddSearchProviderCallback& confirm_add_callback,
     ProviderType provider_type) {
   DCHECK(osdd_url.is_valid());
 
   // For a JS-added OSDD, the provided keyword is irrelevant because we will
   // generate a keyword later from the OSDD content.  For the autodetected case,
   // we need a valid keyword up front.
   if (provider_type == TemplateURLFetcher::AUTODETECTED_PROVIDER) {
     DCHECK(!keyword.empty());
 
     if (!template_url_service_->loaded()) {
@@ skipping 11 matching lines @@
   }
 
   // Make sure we aren't already downloading this request.
   for (Requests::iterator i = requests_.begin(); i != requests_.end(); ++i) {
     if (((*i)->url() == osdd_url) ||
         ((provider_type == TemplateURLFetcher::AUTODETECTED_PROVIDER) &&
          ((*i)->keyword() == keyword)))
       return;
   }
 
-  requests_.push_back(
-      new RequestDelegate(this, keyword, osdd_url, favicon_url, web_contents,
-                          callback, provider_type));
+  requests_.push_back(new RequestDelegate(
+      this, keyword, osdd_url, favicon_url, url_fetcher_customize_callback,
+      confirm_add_callback, provider_type));
 }
 
 void TemplateURLFetcher::RequestCompleted(RequestDelegate* request) {
   Requests::iterator i =
       std::find(requests_.begin(), requests_.end(), request);
   DCHECK(i != requests_.end());
   requests_.weak_erase(i);
   delete request;
 }