Add basic support of URL/search query to Athena home card.

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 "base/strings/utf_string_conversions.h"
+#include "components/autocomplete/autocomplete_input.h"
+#include "components/autocomplete/autocomplete_scheme_classifier.h"
+#include "components/metrics/proto/omnibox_event.pb.h"
+#include "components/metrics/proto/omnibox_input_type.pb.h"
+#include "components/search_engines/search_terms_data.h"
+#include "components/search_engines/template_url.h"
+#include "components/search_engines/template_url_service.h"
+#include "components/search_engines/template_url_service_client.h"
+#include "net/url_request/url_request.h"
 #include "ui/app_list/search_result.h"
 #include "url/gurl.h"
 
 namespace athena {
 
 namespace {
 
+// 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 {}
+
+  DISALLOW_COPY_AND_ASSIGN(AthenaTemplateURLServiceClient);
+};
+
 class UrlSearchResult : public app_list::SearchResult {
  public:
   UrlSearchResult(content::BrowserContext* browser_context,
+                  TemplateURLService* template_url_service,
                   const base::string16& query)
-      : browser_context_(browser_context), url_(query) {
+      : browser_context_(browser_context),
+        template_url_service_(template_url_service),
+        input_(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()) {
     set_title(query);
     app_list::SearchResult::Tags title_tags;
+    if (input_.type() == metrics::OmniboxInputType::URL) {
+      title_tags.push_back(app_list::SearchResult::Tag(
+          app_list::SearchResult::Tag::URL, 0, query.size()));
+    }
     title_tags.push_back(app_list::SearchResult::Tag(
-        app_list::SearchResult::Tag::URL, 0, query.size()));
+        app_list::SearchResult::Tag::MATCH, 0, query.size()));
     set_title_tags(title_tags);
     set_id(base::UTF16ToUTF8(query));
   }
 
  private:
   // Overriddenn from app_list::SearchResult:
   virtual void Open(int event_flags) OVERRIDE {
+    GURL url;
+    if (input_.type() == metrics::OmniboxInputType::URL) {
+      url = input_.canonicalized_url();
+    } else {
+      TemplateURL* template_url =
+          template_url_service_->GetDefaultSearchProvider();
+      const TemplateURLRef& search_url = template_url->url_ref();
+      TemplateURLRef::SearchTermsArgs search_terms_args(input_.text());
+      url = GURL(search_url.ReplaceSearchTerms(
+          search_terms_args, template_url_service_->search_terms_data()));
+    }
     ActivityManager::Get()->AddActivity(
-        ActivityFactory::Get()->CreateWebActivity(browser_context_, url_));
+        ActivityFactory::Get()->CreateWebActivity(browser_context_, url));
   }
 
   content::BrowserContext* browser_context_;
-  const GURL url_;
+  TemplateURLService* template_url_service_;
+  AutocompleteInput input_;
 
   DISALLOW_COPY_AND_ASSIGN(UrlSearchResult);
 };
 
 }  // namespace
 
 UrlSearchProvider::UrlSearchProvider(content::BrowserContext* browser_context)
-    : browser_context_(browser_context) {
+    : browser_context_(browser_context),
+      // TODO(mukai): introduce the real parameters when it's necessary.
+      template_url_service_(
+          new TemplateURLService(NULL /* prefs */,
+                                 make_scoped_ptr(new SearchTermsData()),
+                                 NULL /* KeywordWebDataService */,
+                                 scoped_ptr<TemplateURLServiceClient>(
+                                     new AthenaTemplateURLServiceClient()),
+                                 NULL /*GoogleURLTracker */,
+                                 NULL /* RapporService */,
+                                 base::Closure() /* dsp_change_callback */)) {
+  template_url_service_->Load();
 }
 
 UrlSearchProvider::~UrlSearchProvider() {
 }
 
 void UrlSearchProvider::Start(const base::string16& query) {
   ClearResults();
-  Add(scoped_ptr<app_list::SearchResult>(
-      new UrlSearchResult(browser_context_, query)));
+  Add(scoped_ptr<app_list::SearchResult>(new UrlSearchResult(
+      browser_context_, template_url_service_.get(), query)));
 }
 
 void UrlSearchProvider::Stop() {
 }
 
 }  // namespace athena