Use ChromeAutocompleteSchemeClassifier for Athena on Chrome.

athena/main/url_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 "athena/main/url_search_provider.h"
 
 #include "athena/activity/public/activity_factory.h"
 #include "athena/activity/public/activity_manager.h"
+#include "athena/content/public/scheme_classifier_factory.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "components/metrics/proto/omnibox_event.pb.h"
 #include "components/metrics/proto/omnibox_input_type.pb.h"
 #include "components/omnibox/autocomplete_input.h"
 #include "components/omnibox/autocomplete_provider_client.h"
-#include "components/omnibox/autocomplete_scheme_classifier.h"
 #include "components/omnibox/search_provider.h"
 #include "components/search_engines/search_terms_data.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/search_engines/template_url_service_client.h"
 #include "content/public/browser/browser_context.h"
 #include "ui/app_list/search_result.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/gurl.h"
 
 namespace athena {
 
 namespace {
 
 // This constant was copied from HistoryURLProvider.
 // TODO(hashimoto): Componentize HistoryURLProvider and delete this.
 const int kScoreForWhatYouTypedResult = 1203;
 
 // The SearchTermsData implementation for Athena.
 class AthenaSearchTermsData : public SearchTermsData {
  public:
   // SearchTermsData:
   virtual std::string GetSuggestClient() const OVERRIDE {
     return "chrome";
   }
 };
 
-// The AutocompleteSchemeClassifier implementation for Athena.
-// TODO(mukai): Introduce supports of normal schemes like about: or blob:
-class AthenaSchemeClassifier : public AutocompleteSchemeClassifier {
- public:
-  AthenaSchemeClassifier() {}
-
-  // AutocompleteSchemeClassifier:
-  virtual metrics::OmniboxInputType::Type GetInputTypeForScheme(
-      const std::string& scheme) const OVERRIDE {
-    if (net::URLRequest::IsHandledProtocol(scheme))
-      return metrics::OmniboxInputType::URL;
-    return metrics::OmniboxInputType::INVALID;
-  }
-};
-
 // The templateURLServiceClient for Athena. Mainly for the interaction with
 // history module (see chrome/browser/search_engines for Chrome implementation).
 // TODO(mukai): Implement the contents of this class when it's necessary.
 class AthenaTemplateURLServiceClient : public TemplateURLServiceClient {
  public:
   AthenaTemplateURLServiceClient() {}
   virtual ~AthenaTemplateURLServiceClient() {}
 
  private:
   // TemplateURLServiceClient:
   virtual void SetOwner(TemplateURLService* owner) OVERRIDE {}
   virtual void DeleteAllSearchTermsForKeyword(TemplateURLID id) OVERRIDE {}
   virtual void SetKeywordSearchTermsForURL(
       const GURL& url,
       TemplateURLID id,
       const base::string16& term) OVERRIDE {}
   virtual void AddKeywordGeneratedVisit(const GURL& url) OVERRIDE {}
   virtual void RestoreExtensionInfoIfNecessary(
       TemplateURL* template_url) OVERRIDE {}
 
   DISALLOW_COPY_AND_ASSIGN(AthenaTemplateURLServiceClient);
 };
 
 // The AutocompleteProviderClient for Athena.
 class AthenaAutocompleteProviderClient : public AutocompleteProviderClient {
  public:
   explicit AthenaAutocompleteProviderClient(
       content::BrowserContext* browser_context)
-      : browser_context_(browser_context) {}
+      : browser_context_(browser_context),
+        scheme_classifier_(CreateSchemeClassifier(browser_context)) {}
   virtual ~AthenaAutocompleteProviderClient() {}
 
   virtual net::URLRequestContextGetter* RequestContext() OVERRIDE {
     return browser_context_->GetRequestContext();
   }
   virtual bool IsOffTheRecord() OVERRIDE {
     return browser_context_->IsOffTheRecord();
   }
   virtual std::string AcceptLanguages() OVERRIDE {
     // TODO(hashimoto): Return the value stored in the prefs.
     return "en-US";
   }
   virtual bool SearchSuggestEnabled() OVERRIDE { return true; }
   virtual bool ShowBookmarkBar() OVERRIDE { return false; }
   virtual const AutocompleteSchemeClassifier& SchemeClassifier() OVERRIDE {
-    return scheme_classifier_;
+    return *scheme_classifier_;
   }
   virtual void Classify(
       const base::string16& text,
       bool prefer_keyword,
       bool allow_exact_keyword_match,
       metrics::OmniboxEventProto::PageClassification page_classification,
       AutocompleteMatch* match,
       GURL* alternate_nav_url) OVERRIDE {}
   virtual history::URLDatabase* InMemoryDatabase() OVERRIDE { return NULL; }
   virtual void DeleteMatchingURLsForKeywordFromHistory(
       history::KeywordID keyword_id,
       const base::string16& term) OVERRIDE {}
   virtual bool TabSyncEnabledAndUnencrypted() OVERRIDE { return false; }
   virtual void PrefetchImage(const GURL& url) OVERRIDE {}
 
  private:
   content::BrowserContext* browser_context_;
-  AthenaSchemeClassifier scheme_classifier_;
+  scoped_ptr<AutocompleteSchemeClassifier> scheme_classifier_;
 
   DISALLOW_COPY_AND_ASSIGN(AthenaAutocompleteProviderClient);
 };
 
 int ACMatchStyleToTagStyle(int styles) {
   int tag_styles = 0;
   if (styles & ACMatchClassification::URL)
     tag_styles |= app_list::SearchResult::Tag::URL;
   if (styles & ACMatchClassification::MATCH)
     tag_styles |= app_list::SearchResult::Tag::MATCH;
@@ skipping 109 matching lines @@
           scoped_ptr<AutocompleteProviderClient>(
               new AthenaAutocompleteProviderClient(browser_context_)))) {
   template_url_service_->Load();
 }
 
 UrlSearchProvider::~UrlSearchProvider() {
 }
 
 void UrlSearchProvider::Start(const base::string16& query) {
   const bool minimal_changes = query == input_.text();
+  scoped_ptr<AutocompleteSchemeClassifier> scheme_classifier(
+      CreateSchemeClassifier(browser_context_));
   input_ = AutocompleteInput(query,
                              base::string16::npos /* cursor_position */,
                              base::string16() /* desired_tld */,
                              GURL() /* current_url */,
                              metrics::OmniboxEventProto::INVALID_SPEC,
                              false /* prevent_inline_autocomplete */,
                              false /* prefer_keyword */,
                              true /* allow_extract_keyword_match */,
                              true /* want_asynchronous_matches */,
-                             AthenaSchemeClassifier());
+                             *scheme_classifier);
 
-  provider_->Start(input_, minimal_changes);
-}
-
-void UrlSearchProvider::Stop() {
-  provider_->Stop(false);
-}
-
-void UrlSearchProvider::OnProviderUpdate(bool updated_matches) {
-  if (!updated_matches)
-    return;
-
-  ClearResults();
+  // Clearing results here may cause unexpected results.
+  // TODO(mukai): fix this by fixing crbug.com/415500
+  if (!minimal_changes)
+    ClearResults();
 
   if (input_.type() == metrics::OmniboxInputType::URL) {
     // TODO(hashimoto): Componentize HistoryURLProvider and remove this code.
     AutocompleteMatch what_you_typed_match(
         NULL, 0, false, AutocompleteMatchType::URL_WHAT_YOU_TYPED);
     what_you_typed_match.destination_url = input_.canonicalized_url();
     what_you_typed_match.contents = input_.text();
     what_you_typed_match.relevance = kScoreForWhatYouTypedResult;
     Add(scoped_ptr<app_list::SearchResult>(new UrlSearchResult(
         browser_context_, what_you_typed_match)));
   }
 
+  provider_->Start(input_, minimal_changes);
+}
+
+void UrlSearchProvider::Stop() {
+  provider_->Stop(false);
+}
+
+void UrlSearchProvider::OnProviderUpdate(bool updated_matches) {
+  if (!updated_matches)
+    return;
+
   const ACMatches& matches = provider_->matches();
   for (ACMatches::const_iterator it = matches.begin(); it != matches.end();
        ++it) {
     if (!it->destination_url.is_valid())
       continue;
 
     Add(scoped_ptr<app_list::SearchResult>(new UrlSearchResult(
         browser_context_, *it)));
   }
 }
 
 }  // namespace athena