src/chrome/browser/android/omnibox/autocomplete_controller_android.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/android/omnibox/autocomplete_controller_android.h"
   6
   7 #include "base/android/jni_android.h"
   8 #include "base/android/jni_string.h"
   9 #include "base/prefs/pref_service.h"
  10 #include "base/strings/string16.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "base/time/time.h"
  13 #include "base/timer/timer.h"
  14 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
  15 #include "chrome/browser/autocomplete/autocomplete_classifier_factory.h"
  16 #include "chrome/browser/autocomplete/autocomplete_controller.h"
  17 #include "chrome/browser/autocomplete/autocomplete_input.h"
  18 #include "chrome/browser/autocomplete/autocomplete_match.h"
  19 #include "chrome/browser/autocomplete/search_provider.h"
  20 #include "chrome/browser/autocomplete/shortcuts_backend_factory.h"
  21 #include "chrome/browser/browser_process.h"
  22 #include "chrome/browser/chrome_notification_types.h"
  23 #include "chrome/browser/omnibox/omnibox_field_trial.h"
  24 #include "chrome/browser/omnibox/omnibox_log.h"
  25 #include "chrome/browser/profiles/incognito_helpers.h"
  26 #include "chrome/browser/profiles/profile_android.h"
  27 #include "chrome/browser/profiles/profile_manager.h"
  28 #include "chrome/browser/search/search.h"
  29 #include "chrome/browser/search_engines/template_url_service.h"
  30 #include "chrome/browser/search_engines/template_url_service_factory.h"
  31 #include "chrome/browser/sessions/session_id.h"
  32 #include "chrome/browser/ui/search/instant_search_prerenderer.h"
  33 #include "chrome/browser/ui/toolbar/toolbar_model.h"
  34 #include "chrome/common/autocomplete_match_type.h"
  35 #include "chrome/common/instant_types.h"
  36 #include "chrome/common/pref_names.h"
  37 #include "chrome/common/url_constants.h"
  38 #include "components/keyed_service/content/browser_context_dependency_manager.h"
  39 #include "components/metrics/proto/omnibox_event.pb.h"
  40 #include "content/public/browser/notification_details.h"
  41 #include "content/public/browser/notification_service.h"
  42 #include "content/public/browser/notification_source.h"
  43 #include "content/public/browser/web_contents.h"
  44 #include "content/public/common/url_constants.h"
  45 #include "jni/AutocompleteController_jni.h"
  46 #include "net/base/escape.h"
  47 #include "net/base/net_util.h"
  48 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
  49 #include "ui/base/resource/resource_bundle.h"
  50
  51 using base::android::AttachCurrentThread;
  52 using base::android::ConvertJavaStringToUTF16;
  53 using base::android::ConvertUTF8ToJavaString;
  54 using base::android::ConvertUTF16ToJavaString;
  55 using metrics::OmniboxEventProto;
  56
  57 namespace {
  58
  59 const int kAndroidAutocompleteProviders =
  60     AutocompleteClassifier::kDefaultOmniboxProviders;
  61
  62 /**
  63  * A prefetcher class responsible for triggering zero suggest prefetch.
  64  * The prefetch occurs as a side-effect of calling StartZeroSuggest() on
  65  * the AutocompleteController object.
  66  */
  67 class ZeroSuggestPrefetcher : public AutocompleteControllerDelegate {
  68  public:
  69   explicit ZeroSuggestPrefetcher(Profile* profile);
  70
  71  private:
  72   virtual ~ZeroSuggestPrefetcher();
  73   void SelfDestruct();
  74
  75   // AutocompleteControllerDelegate:
  76   virtual void OnResultChanged(bool default_match_changed) OVERRIDE;
  77
  78   scoped_ptr<AutocompleteController> controller_;
  79   base::OneShotTimer<ZeroSuggestPrefetcher> expire_timer_;
  80 };
  81
  82 ZeroSuggestPrefetcher::ZeroSuggestPrefetcher(Profile* profile) : controller_(
  83     new AutocompleteController(profile, this,
  84                                AutocompleteProvider::TYPE_ZERO_SUGGEST)) {
  85   // Creating an arbitrary fake_request_source to avoid passing in an invalid
  86   // AutocompleteInput object.
  87   base::string16 fake_request_source(base::ASCIIToUTF16(
  88       "http://www.foobarbazblah.com"));
  89   controller_->StartZeroSuggest(AutocompleteInput(
  90       fake_request_source,
  91       base::string16::npos,
  92       base::string16(),
  93       GURL(fake_request_source),
  94       OmniboxEventProto::INVALID_SPEC,
  95       false,
  96       false,
  97       true,
  98       true));
  99   // Delete ourselves after 10s. This is enough time to cache results or
 100   // give up if the results haven't been received.
 101   expire_timer_.Start(FROM_HERE,
 102                       base::TimeDelta::FromMilliseconds(10000),
 103                       this, &ZeroSuggestPrefetcher::SelfDestruct);
 104 }
 105
 106 ZeroSuggestPrefetcher::~ZeroSuggestPrefetcher() {
 107 }
 108
 109 void ZeroSuggestPrefetcher::SelfDestruct() {
 110   delete this;
 111 }
 112
 113 void ZeroSuggestPrefetcher::OnResultChanged(bool default_match_changed) {
 114   // Nothing to do here, the results have been cached.
 115   // We don't want to trigger deletion here because this is being called by the
 116   // AutocompleteController object.
 117 }
 118
 119 }  // namespace
 120
 121 AutocompleteControllerAndroid::AutocompleteControllerAndroid(Profile* profile)
 122     : autocomplete_controller_(new AutocompleteController(
 123           profile, this, kAndroidAutocompleteProviders)),
 124       inside_synchronous_start_(false),
 125       profile_(profile) {
 126 }
 127
 128 void AutocompleteControllerAndroid::Start(JNIEnv* env,
 129                                           jobject obj,
 130                                           jstring j_text,
 131                                           jstring j_desired_tld,
 132                                           jstring j_current_url,
 133                                           bool prevent_inline_autocomplete,
 134                                           bool prefer_keyword,
 135                                           bool allow_exact_keyword_match,
 136                                           bool want_asynchronous_matches) {
 137   if (!autocomplete_controller_)
 138     return;
 139
 140   base::string16 desired_tld;
 141   GURL current_url;
 142   if (j_current_url != NULL)
 143     current_url = GURL(ConvertJavaStringToUTF16(env, j_current_url));
 144   if (j_desired_tld != NULL)
 145     desired_tld = ConvertJavaStringToUTF16(env, j_desired_tld);
 146   base::string16 text = ConvertJavaStringToUTF16(env, j_text);
 147   OmniboxEventProto::PageClassification page_classification =
 148       OmniboxEventProto::OTHER;
 149   input_ = AutocompleteInput(text,
 150                              base::string16::npos,
 151                              desired_tld,
 152                              current_url,
 153                              page_classification,
 154                              prevent_inline_autocomplete,
 155                              prefer_keyword,
 156                              allow_exact_keyword_match,
 157                              want_asynchronous_matches);
 158   autocomplete_controller_->Start(input_);
 159 }
 160
 161 ScopedJavaLocalRef<jobject> AutocompleteControllerAndroid::Classify(
 162     JNIEnv* env,
 163     jobject obj,
 164     jstring j_text) {
 165   return GetTopSynchronousResult(env, obj, j_text, true);
 166 }
 167
 168 void AutocompleteControllerAndroid::StartZeroSuggest(
 169     JNIEnv* env,
 170     jobject obj,
 171     jstring j_omnibox_text,
 172     jstring j_current_url,
 173     jboolean is_query_in_omnibox,
 174     jboolean focused_from_fakebox) {
 175   if (!autocomplete_controller_)
 176     return;
 177
 178   base::string16 url = ConvertJavaStringToUTF16(env, j_current_url);
 179   const GURL current_url = GURL(url);
 180   base::string16 omnibox_text = ConvertJavaStringToUTF16(env, j_omnibox_text);
 181
 182   // If omnibox text is empty, set it to the current URL for the purposes of
 183   // populating the verbatim match.
 184   if (omnibox_text.empty())
 185     omnibox_text = url;
 186
 187   input_ = AutocompleteInput(
 188       omnibox_text, base::string16::npos, base::string16(), current_url,
 189       ClassifyPage(current_url, is_query_in_omnibox, focused_from_fakebox),
 190       false, false, true, true);
 191   autocomplete_controller_->StartZeroSuggest(input_);
 192 }
 193
 194 void AutocompleteControllerAndroid::Stop(JNIEnv* env,
 195                                          jobject obj,
 196                                          bool clear_results) {
 197   if (autocomplete_controller_ != NULL)
 198     autocomplete_controller_->Stop(clear_results);
 199 }
 200
 201 void AutocompleteControllerAndroid::ResetSession(JNIEnv* env, jobject obj) {
 202   if (autocomplete_controller_ != NULL)
 203     autocomplete_controller_->ResetSession();
 204 }
 205
 206 void AutocompleteControllerAndroid::OnSuggestionSelected(
 207     JNIEnv* env,
 208     jobject obj,
 209     jint selected_index,
 210     jstring j_current_url,
 211     jboolean is_query_in_omnibox,
 212     jboolean focused_from_fakebox,
 213     jlong elapsed_time_since_first_modified,
 214     jobject j_web_contents) {
 215   base::string16 url = ConvertJavaStringToUTF16(env, j_current_url);
 216   const GURL current_url = GURL(url);
 217   OmniboxEventProto::PageClassification current_page_classification =
 218       ClassifyPage(current_url, is_query_in_omnibox, focused_from_fakebox);
 219   const base::TimeTicks& now(base::TimeTicks::Now());
 220   content::WebContents* web_contents =
 221       content::WebContents::FromJavaWebContents(j_web_contents);
 222
 223   OmniboxLog log(
 224       input_.text(),
 225       false, /* don't know */
 226       input_.type(),
 227       true,
 228       selected_index,
 229       false,
 230       SessionID::IdForTab(web_contents),
 231       current_page_classification,
 232       base::TimeDelta::FromMilliseconds(elapsed_time_since_first_modified),
 233       base::string16::npos,
 234       now - autocomplete_controller_->last_time_default_match_changed(),
 235       autocomplete_controller_->result());
 236   autocomplete_controller_->AddProvidersInfo(&log.providers_info);
 237
 238   content::NotificationService::current()->Notify(
 239       chrome::NOTIFICATION_OMNIBOX_OPENED_URL,
 240       content::Source<Profile>(profile_),
 241       content::Details<OmniboxLog>(&log));
 242 }
 243
 244 void AutocompleteControllerAndroid::DeleteSuggestion(JNIEnv* env,
 245                                                      jobject obj,
 246                                                      int selected_index) {
 247   const AutocompleteResult& result = autocomplete_controller_->result();
 248   const AutocompleteMatch& match = result.match_at(selected_index);
 249   if (match.SupportsDeletion())
 250     autocomplete_controller_->DeleteMatch(match);
 251 }
 252
 253 ScopedJavaLocalRef<jstring>
 254 AutocompleteControllerAndroid::UpdateMatchDestinationURL(
 255     JNIEnv* env,
 256     jobject obj,
 257     jint selected_index,
 258     jlong elapsed_time_since_input_change) {
 259   // In rare cases, we navigate to cached matches and the underlying result
 260   // has already been cleared, in that case ignore the URL update.
 261   if (autocomplete_controller_->result().empty())
 262     return ScopedJavaLocalRef<jstring>();
 263
 264   AutocompleteMatch match(
 265       autocomplete_controller_->result().match_at(selected_index));
 266   autocomplete_controller_->UpdateMatchDestinationURL(
 267       base::TimeDelta::FromMilliseconds(elapsed_time_since_input_change),
 268       &match);
 269   return ConvertUTF8ToJavaString(env, match.destination_url.spec());
 270 }
 271
 272 ScopedJavaLocalRef<jobject>
 273 AutocompleteControllerAndroid::GetTopSynchronousMatch(JNIEnv* env,
 274                                                       jobject obj,
 275                                                       jstring query) {
 276   return GetTopSynchronousResult(env, obj, query, false);
 277 }
 278
 279 void AutocompleteControllerAndroid::Shutdown() {
 280   autocomplete_controller_.reset();
 281
 282   JNIEnv* env = AttachCurrentThread();
 283   ScopedJavaLocalRef<jobject> java_bridge =
 284       weak_java_autocomplete_controller_android_.get(env);
 285   if (java_bridge.obj())
 286     Java_AutocompleteController_notifyNativeDestroyed(env, java_bridge.obj());
 287
 288   weak_java_autocomplete_controller_android_.reset();
 289 }
 290
 291 // static
 292 AutocompleteControllerAndroid*
 293 AutocompleteControllerAndroid::Factory::GetForProfile(
 294     Profile* profile, JNIEnv* env, jobject obj) {
 295   AutocompleteControllerAndroid* bridge =
 296       static_cast<AutocompleteControllerAndroid*>(
 297           GetInstance()->GetServiceForBrowserContext(profile, true));
 298   bridge->InitJNI(env, obj);
 299   return bridge;
 300 }
 301
 302 AutocompleteControllerAndroid::Factory*
 303 AutocompleteControllerAndroid::Factory::GetInstance() {
 304   return Singleton<AutocompleteControllerAndroid::Factory>::get();
 305 }
 306
 307 content::BrowserContext*
 308 AutocompleteControllerAndroid::Factory::GetBrowserContextToUse(
 309     content::BrowserContext* context) const {
 310   return chrome::GetBrowserContextOwnInstanceInIncognito(context);
 311 }
 312
 313 AutocompleteControllerAndroid::Factory::Factory()
 314     : BrowserContextKeyedServiceFactory(
 315           "AutocompleteControllerAndroid",
 316           BrowserContextDependencyManager::GetInstance()) {
 317   DependsOn(ShortcutsBackendFactory::GetInstance());
 318 }
 319
 320 AutocompleteControllerAndroid::Factory::~Factory() {
 321 }
 322
 323 KeyedService* AutocompleteControllerAndroid::Factory::BuildServiceInstanceFor(
 324     content::BrowserContext* profile) const {
 325   return new AutocompleteControllerAndroid(static_cast<Profile*>(profile));
 326 }
 327
 328 AutocompleteControllerAndroid::~AutocompleteControllerAndroid() {
 329 }
 330
 331 void AutocompleteControllerAndroid::InitJNI(JNIEnv* env, jobject obj) {
 332   weak_java_autocomplete_controller_android_ =
 333       JavaObjectWeakGlobalRef(env, obj);
 334 }
 335
 336 void AutocompleteControllerAndroid::OnResultChanged(
 337     bool default_match_changed) {
 338   if (!autocomplete_controller_)
 339     return;
 340
 341   const AutocompleteResult& result = autocomplete_controller_->result();
 342   const AutocompleteResult::const_iterator default_match(
 343       result.default_match());
 344   if ((default_match != result.end()) && default_match_changed &&
 345       chrome::IsInstantExtendedAPIEnabled() &&
 346       chrome::ShouldPrefetchSearchResults()) {
 347     InstantSuggestion prefetch_suggestion;
 348     // If the default match should be prefetched, do that.
 349     if (SearchProvider::ShouldPrefetch(*default_match)) {
 350       prefetch_suggestion.text = default_match->contents;
 351       prefetch_suggestion.metadata =
 352           SearchProvider::GetSuggestMetadata(*default_match);
 353     }
 354     // Send the prefetch suggestion unconditionally to the Instant search base
 355     // page. If there is no suggestion to prefetch, we need to send a blank
 356     // query to clear the prefetched results.
 357     InstantSearchPrerenderer* prerenderer =
 358         InstantSearchPrerenderer::GetForProfile(profile_);
 359     if (prerenderer)
 360       prerenderer->Prerender(prefetch_suggestion);
 361   }
 362   if (!inside_synchronous_start_)
 363     NotifySuggestionsReceived(autocomplete_controller_->result());
 364 }
 365
 366 void AutocompleteControllerAndroid::NotifySuggestionsReceived(
 367     const AutocompleteResult& autocomplete_result) {
 368   JNIEnv* env = AttachCurrentThread();
 369   ScopedJavaLocalRef<jobject> java_bridge =
 370       weak_java_autocomplete_controller_android_.get(env);
 371   if (!java_bridge.obj())
 372     return;
 373
 374   ScopedJavaLocalRef<jobject> suggestion_list_obj =
 375       Java_AutocompleteController_createOmniboxSuggestionList(
 376           env, autocomplete_result.size());
 377   for (size_t i = 0; i < autocomplete_result.size(); ++i) {
 378     ScopedJavaLocalRef<jobject> j_omnibox_suggestion =
 379         BuildOmniboxSuggestion(env, autocomplete_result.match_at(i));
 380     Java_AutocompleteController_addOmniboxSuggestionToList(
 381         env, suggestion_list_obj.obj(), j_omnibox_suggestion.obj());
 382   }
 383
 384   // Get the inline-autocomplete text.
 385   const AutocompleteResult::const_iterator default_match(
 386       autocomplete_result.default_match());
 387   base::string16 inline_autocomplete_text;
 388   if (default_match != autocomplete_result.end()) {
 389     inline_autocomplete_text = default_match->inline_autocompletion;
 390   }
 391   ScopedJavaLocalRef<jstring> inline_text =
 392       ConvertUTF16ToJavaString(env, inline_autocomplete_text);
 393   jlong j_autocomplete_result =
 394       reinterpret_cast<intptr_t>(&(autocomplete_result));
 395   Java_AutocompleteController_onSuggestionsReceived(env,
 396                                                     java_bridge.obj(),
 397                                                     suggestion_list_obj.obj(),
 398                                                     inline_text.obj(),
 399                                                     j_autocomplete_result);
 400 }
 401
 402 OmniboxEventProto::PageClassification
 403 AutocompleteControllerAndroid::ClassifyPage(const GURL& gurl,
 404                                             bool is_query_in_omnibox,
 405                                             bool focused_from_fakebox) const {
 406   if (!gurl.is_valid())
 407     return OmniboxEventProto::INVALID_SPEC;
 408
 409   const std::string& url = gurl.spec();
 410
 411   if (gurl.SchemeIs(content::kChromeUIScheme) &&
 412       gurl.host() == chrome::kChromeUINewTabHost) {
 413     return OmniboxEventProto::NTP;
 414   }
 415
 416   if (url == chrome::kChromeUINativeNewTabURL) {
 417     return focused_from_fakebox ?
 418         OmniboxEventProto::INSTANT_NTP_WITH_FAKEBOX_AS_STARTING_FOCUS :
 419         OmniboxEventProto::INSTANT_NTP_WITH_OMNIBOX_AS_STARTING_FOCUS;
 420   }
 421
 422   if (url == url::kAboutBlankURL)
 423     return OmniboxEventProto::BLANK;
 424
 425   if (url == profile_->GetPrefs()->GetString(prefs::kHomePage))
 426     return OmniboxEventProto::HOME_PAGE;
 427
 428   if (is_query_in_omnibox)
 429     return OmniboxEventProto::SEARCH_RESULT_PAGE_DOING_SEARCH_TERM_REPLACEMENT;
 430
 431   bool is_search_url = TemplateURLServiceFactory::GetForProfile(profile_)->
 432       IsSearchResultsPageFromDefaultSearchProvider(gurl);
 433   if (is_search_url)
 434     return OmniboxEventProto::SEARCH_RESULT_PAGE_NO_SEARCH_TERM_REPLACEMENT;
 435
 436   return OmniboxEventProto::OTHER;
 437 }
 438
 439 ScopedJavaLocalRef<jobject>
 440 AutocompleteControllerAndroid::BuildOmniboxSuggestion(
 441     JNIEnv* env,
 442     const AutocompleteMatch& match) {
 443   ScopedJavaLocalRef<jstring> contents =
 444       ConvertUTF16ToJavaString(env, match.contents);
 445   ScopedJavaLocalRef<jstring> description =
 446       ConvertUTF16ToJavaString(env, match.description);
 447   ScopedJavaLocalRef<jstring> answer_contents =
 448       ConvertUTF16ToJavaString(env, match.answer_contents);
 449   ScopedJavaLocalRef<jstring> answer_type =
 450       ConvertUTF16ToJavaString(env, match.answer_type);
 451   ScopedJavaLocalRef<jstring> fill_into_edit =
 452       ConvertUTF16ToJavaString(env, match.fill_into_edit);
 453   ScopedJavaLocalRef<jstring> destination_url =
 454       ConvertUTF8ToJavaString(env, match.destination_url.spec());
 455   // Note that we are also removing 'www' host from formatted url.
 456   ScopedJavaLocalRef<jstring> formatted_url = ConvertUTF16ToJavaString(env,
 457       FormatURLUsingAcceptLanguages(match.stripped_destination_url));
 458   return Java_AutocompleteController_buildOmniboxSuggestion(
 459       env,
 460       match.type,
 461       match.relevance,
 462       match.transition,
 463       contents.obj(),
 464       description.obj(),
 465       answer_contents.obj(),
 466       answer_type.obj(),
 467       fill_into_edit.obj(),
 468       destination_url.obj(),
 469       formatted_url.obj(),
 470       match.starred,
 471       match.SupportsDeletion());
 472 }
 473
 474 base::string16 AutocompleteControllerAndroid::FormatURLUsingAcceptLanguages(
 475     GURL url) {
 476   if (profile_ == NULL)
 477     return base::string16();
 478
 479   std::string languages(
 480       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages));
 481
 482   return net::FormatUrl(url, languages, net::kFormatUrlOmitAll,
 483       net::UnescapeRule::SPACES, NULL, NULL, NULL);
 484 }
 485
 486 ScopedJavaLocalRef<jobject>
 487 AutocompleteControllerAndroid::GetTopSynchronousResult(
 488     JNIEnv* env,
 489     jobject obj,
 490     jstring j_text,
 491     bool prevent_inline_autocomplete) {
 492   if (!autocomplete_controller_)
 493     return ScopedJavaLocalRef<jobject>();
 494
 495   inside_synchronous_start_ = true;
 496   Start(env,
 497         obj,
 498         j_text,
 499         NULL,
 500         NULL,
 501         prevent_inline_autocomplete,
 502         false,
 503         false,
 504         false);
 505   inside_synchronous_start_ = false;
 506   DCHECK(autocomplete_controller_->done());
 507   const AutocompleteResult& result = autocomplete_controller_->result();
 508   if (result.empty())
 509     return ScopedJavaLocalRef<jobject>();
 510
 511   return BuildOmniboxSuggestion(env, *result.begin());
 512 }
 513
 514 static jlong Init(JNIEnv* env, jobject obj, jobject jprofile) {
 515   Profile* profile = ProfileAndroid::FromProfileAndroid(jprofile);
 516   if (!profile)
 517     return 0;
 518
 519   AutocompleteControllerAndroid* native_bridge =
 520       AutocompleteControllerAndroid::Factory::GetForProfile(profile, env, obj);
 521   return reinterpret_cast<intptr_t>(native_bridge);
 522 }
 523
 524 static jstring QualifyPartialURLQuery(
 525     JNIEnv* env, jclass clazz, jstring jquery) {
 526   Profile* profile = ProfileManager::GetActiveUserProfile();
 527   if (!profile)
 528     return NULL;
 529   AutocompleteMatch match;
 530   base::string16 query_string(ConvertJavaStringToUTF16(env, jquery));
 531   AutocompleteClassifierFactory::GetForProfile(profile)->Classify(
 532       query_string,
 533       false,
 534       false,
 535       OmniboxEventProto::INVALID_SPEC,
 536       &match,
 537       NULL);
 538   if (!match.destination_url.is_valid())
 539     return NULL;
 540
 541   // Only return a URL if the match is a URL type.
 542   if (match.type != AutocompleteMatchType::URL_WHAT_YOU_TYPED &&
 543       match.type != AutocompleteMatchType::HISTORY_URL &&
 544       match.type != AutocompleteMatchType::NAVSUGGEST)
 545     return NULL;
 546
 547   // As we are returning to Java, it is fine to call Release().
 548   return ConvertUTF8ToJavaString(env, match.destination_url.spec()).Release();
 549 }
 550
 551 static void PrefetchZeroSuggestResults(JNIEnv* env, jclass clazz) {
 552   Profile* profile = ProfileManager::GetActiveUserProfile();
 553   if (!profile)
 554     return;
 555
 556   if (!OmniboxFieldTrial::InZeroSuggestPersonalizedFieldTrial())
 557     return;
 558
 559   // ZeroSuggestPrefetcher deletes itself after it's done prefetching.
 560   new ZeroSuggestPrefetcher(profile);
 561 }
 562
 563 // Register native methods
 564 bool RegisterAutocompleteControllerAndroid(JNIEnv* env) {
 565   return RegisterNativesImpl(env);
 566 }