Rename AutocompleteProviderDelegate to AutocompleteProviderClient

components/omnibox/base_search_provider.cc

 // Copyright 2014 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 "components/omnibox/base_search_provider.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
-#include "components/omnibox/autocomplete_provider_delegate.h"
+#include "components/omnibox/autocomplete_provider_client.h"
 #include "components/omnibox/autocomplete_provider_listener.h"
 #include "components/omnibox/omnibox_field_trial.h"
 #include "components/search_engines/template_url.h"
 #include "components/search_engines/template_url_prepopulate_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "url/gurl.h"
 
@@ skipping 54 matching lines @@
 
 // BaseSearchProvider ---------------------------------------------------------
 
 // static
 const int BaseSearchProvider::kDefaultProviderURLFetcherID = 1;
 const int BaseSearchProvider::kKeywordProviderURLFetcherID = 2;
 const int BaseSearchProvider::kDeletionURLFetcherID = 3;
 
 BaseSearchProvider::BaseSearchProvider(
     TemplateURLService* template_url_service,
-    scoped_ptr<AutocompleteProviderDelegate> delegate,
+    scoped_ptr<AutocompleteProviderClient> client,
     AutocompleteProvider::Type type)
     : AutocompleteProvider(type),
       template_url_service_(template_url_service),
-      delegate_(delegate.Pass()),
+      client_(client.Pass()),
       field_trial_triggered_(false),
       field_trial_triggered_in_session_(false) {
 }
 
 // static
 bool BaseSearchProvider::ShouldPrefetch(const AutocompleteMatch& match) {
   return match.GetAdditionalInfo(kShouldPrefetchKey) == kTrue;
 }
 
 // static
@@ skipping 12 matching lines @@
           base::string16(), base::string16(), std::string(), std::string(),
           from_keyword_provider, 0, false, false, base::string16()),
       template_url, search_terms_data, 0, false);
 }
 
 void BaseSearchProvider::DeleteMatch(const AutocompleteMatch& match) {
   DCHECK(match.deletable);
   if (!match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey).empty()) {
     deletion_handlers_.push_back(new SuggestionDeletionHandler(
         match.GetAdditionalInfo(BaseSearchProvider::kDeletionUrlKey),
-        delegate_->RequestContext(),
+        client_->RequestContext(),
         base::Bind(&BaseSearchProvider::OnDeletionComplete,
                    base::Unretained(this))));
   }
 
   TemplateURL* template_url =
       match.GetTemplateURL(template_url_service_, false);
   // This may be NULL if the template corresponding to the keyword has been
   // deleted or there is no keyword set.
   if (template_url != NULL) {
-    delegate_->DeleteMatchingURLsForKeywordFromHistory(template_url->id(),
-                                                       match.contents);
+    client_->DeleteMatchingURLsForKeywordFromHistory(template_url->id(),
+                                                     match.contents);
   }
 
   // Immediately update the list of matches to show the match was deleted,
   // regardless of whether the server request actually succeeds.
   DeleteMatchFromMatches(match);
 }
 
 void BaseSearchProvider::AddProviderInfo(ProvidersInfo* provider_info) const {
   provider_info->push_back(metrics::OmniboxEventProto_ProviderInfo());
   metrics::OmniboxEventProto_ProviderInfo& new_entry = provider_info->back();
@@ skipping 120 matching lines @@
 
   return match;
 }
 
 // static
 bool BaseSearchProvider::ZeroSuggestEnabled(
     const GURL& suggest_url,
     const TemplateURL* template_url,
     OmniboxEventProto::PageClassification page_classification,
     const SearchTermsData& search_terms_data,
-    AutocompleteProviderDelegate* delegate) {
+    AutocompleteProviderClient* client) {
   if (!OmniboxFieldTrial::InZeroSuggestFieldTrial())
     return false;
 
   // Make sure we are sending the suggest request through HTTPS to prevent
   // exposing the current page URL or personalized results without encryption.
   if (!suggest_url.SchemeIs(url::kHttpsScheme))
     return false;
 
   // Don't show zero suggest on the NTP.
   // TODO(hfung): Experiment with showing MostVisited zero suggest on NTP
   // under the conditions described in crbug.com/305366.
   if ((page_classification ==
        OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS) ||
       (page_classification ==
        OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS))
     return false;
 
   // Don't run if in incognito mode.
-  if (delegate->IsOffTheRecord())
+  if (client->IsOffTheRecord())
     return false;
 
   // Don't run if we can't get preferences or search suggest is not enabled.
-  if (!delegate->SearchSuggestEnabled())
+  if (!client->SearchSuggestEnabled())
     return false;
 
   // Only make the request if we know that the provider supports zero suggest
   // (currently only the prepopulated Google provider).
   if (template_url == NULL ||
       !template_url->SupportsReplacement(search_terms_data) ||
       TemplateURLPrepopulateData::GetEngineType(
           *template_url, search_terms_data) != SEARCH_ENGINE_GOOGLE)
     return false;
 
   return true;
 }
 
 // static
 bool BaseSearchProvider::CanSendURL(
     const GURL& current_page_url,
     const GURL& suggest_url,
     const TemplateURL* template_url,
     OmniboxEventProto::PageClassification page_classification,
     const SearchTermsData& search_terms_data,
-    AutocompleteProviderDelegate* delegate) {
+    AutocompleteProviderClient* client) {
   if (!ZeroSuggestEnabled(suggest_url, template_url, page_classification,
-                          search_terms_data, delegate))
+                          search_terms_data, client))
     return false;
 
   if (!current_page_url.is_valid())
     return false;
 
   // Only allow HTTP URLs or HTTPS URLs for the same domain as the search
   // provider.
   if ((current_page_url.scheme() != url::kHttpScheme) &&
       ((current_page_url.scheme() != url::kHttpsScheme) ||
        !net::registry_controlled_domains::SameDomainOrHost(
            current_page_url, suggest_url,
            net::registry_controlled_domains::EXCLUDE_PRIVATE_REGISTRIES)))
     return false;
 
-  if (!delegate->TabSyncEnabledAndUnencrypted())
+  if (!client->TabSyncEnabledAndUnencrypted())
     return false;
 
   return true;
 }
 
 void BaseSearchProvider::AddMatchToMap(
     const SearchSuggestionParser::SuggestResult& result,
     const std::string& metadata,
     int accepted_suggestion,
     bool mark_as_deletable,
     bool in_keyword_mode,
     MatchMap* map) {
   AutocompleteMatch match = CreateSearchSuggestion(
       this, GetInput(result.from_keyword_provider()), in_keyword_mode, result,
       GetTemplateURL(result.from_keyword_provider()),
       template_url_service_->search_terms_data(), accepted_suggestion,
       ShouldAppendExtraParams(result));
   if (!match.destination_url.is_valid())
     return;
-  match.search_terms_args->bookmark_bar_pinned = delegate_->ShowBookmarkBar();
+  match.search_terms_args->bookmark_bar_pinned = client_->ShowBookmarkBar();
   match.RecordAdditionalInfo(kRelevanceFromServerKey,
                              result.relevance_from_server() ? kTrue : kFalse);
   match.RecordAdditionalInfo(kShouldPrefetchKey,
                              result.should_prefetch() ? kTrue : kFalse);
   SetDeletionURL(result.deletion_url(), &match);
   if (mark_as_deletable)
     match.deletable = true;
   // Metadata is needed only for prefetching queries.
   if (result.should_prefetch())
     match.RecordAdditionalInfo(kSuggestMetadataKey, metadata);
@@ skipping 49 matching lines @@
   }
 }
 
 bool BaseSearchProvider::ParseSuggestResults(
     const base::Value& root_val,
     int default_result_relevance,
     bool is_keyword_result,
     SearchSuggestionParser::Results* results) {
   if (!SearchSuggestionParser::ParseSuggestResults(
       root_val, GetInput(is_keyword_result),
-      delegate_->SchemeClassifier(), default_result_relevance,
-      delegate_->AcceptLanguages(), is_keyword_result, results))
+      client_->SchemeClassifier(), default_result_relevance,
+      client_->AcceptLanguages(), is_keyword_result, results))
     return false;
 
   for (std::vector<GURL>::const_iterator it =
            results->answers_image_urls.begin();
        it != results->answers_image_urls.end(); ++it)
-    delegate_->PrefetchImage(*it);
+    client_->PrefetchImage(*it);
 
   field_trial_triggered_ |= results->field_trial_triggered;
   field_trial_triggered_in_session_ |= results->field_trial_triggered;
   return true;
 }
 
 void BaseSearchProvider::DeleteMatchFromMatches(
     const AutocompleteMatch& match) {
   for (ACMatches::iterator i(matches_.begin()); i != matches_.end(); ++i) {
     // Find the desired match to delete by checking the type and contents.
     // We can't check the destination URL, because the autocomplete controller
     // may have reformulated that. Not that while checking for matching
     // contents works for personalized suggestions, if more match types gain
     // deletion support, this algorithm may need to be re-examined.
     if (i->contents == match.contents && i->type == match.type) {
       matches_.erase(i);
       break;
     }
   }
 }
 
 void BaseSearchProvider::OnDeletionComplete(
     bool success, SuggestionDeletionHandler* handler) {
   RecordDeletionResult(success);
   SuggestionDeletionHandlers::iterator it = std::find(
       deletion_handlers_.begin(), deletion_handlers_.end(), handler);
   DCHECK(it != deletion_handlers_.end());
   deletion_handlers_.erase(it);
 }