Persist the Instant API to committed search result pages.

chrome/renderer/searchbox/searchbox_extension.cc

 // Copyright 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 "chrome/renderer/searchbox/searchbox_extension.h"
 
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/renderer/searchbox/searchbox.h"
@@ skipping 301 matching lines @@
 
   return content::RenderView::FromWebView(webview);
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetQuery(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
-  DVLOG(1) << "GetQuery: '" << SearchBox::Get(render_view)->query() << "'";
+  DVLOG(1) << render_view << " GetQuery: '"
+           << SearchBox::Get(render_view)->query() << "'";
   return UTF16ToV8String(SearchBox::Get(render_view)->query());
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetVerbatim(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
-  DVLOG(1) << "GetVerbatim: " << SearchBox::Get(render_view)->verbatim();
+  DVLOG(1) << render_view << " GetVerbatim: "
+           << SearchBox::Get(render_view)->verbatim();
   return v8::Boolean::New(SearchBox::Get(render_view)->verbatim());
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetSelectionStart(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
   return v8::Uint32::New(SearchBox::Get(render_view)->selection_start());
@@ skipping 40 matching lines @@
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
   return v8::Int32::New(SearchBox::Get(render_view)->GetRect().height());
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetAutocompleteResults(
     const v8::Arguments& args) {
-  DVLOG(1) << "GetAutocompleteResults";
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
+  DVLOG(1) << render_view << " GetAutocompleteResults";
   const std::vector<InstantAutocompleteResult>& results =
       SearchBox::Get(render_view)->GetAutocompleteResults();
-  const size_t results_base = SearchBox::Get(render_view)->results_base();
+  size_t results_base = SearchBox::Get(render_view)->results_base();
 
   v8::Handle<v8::Array> results_array = v8::Array::New(results.size());
   for (size_t i = 0; i < results.size(); ++i) {
     v8::Handle<v8::Object> result = v8::Object::New();
     result->Set(v8::String::New("provider"),
                 UTF16ToV8String(results[i].provider));
     result->Set(v8::String::New("type"), UTF16ToV8String(results[i].type));
     result->Set(v8::String::New("contents"),
                 UTF16ToV8String(results[i].description));
     result->Set(v8::String::New("destination_url"),
@@ skipping 10 matching lines @@
   return results_array;
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetContext(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
   const chrome::search::Mode& mode = SearchBox::Get(render_view)->mode();
-  DVLOG(1) << "GetContext: " << mode.origin << ":" << mode.mode;
+  DVLOG(1) << render_view << " GetContext: " << mode.origin << ":" << mode.mode;
   v8::Handle<v8::Object> context = v8::Object::New();
   context->Set(v8::String::New("isNewTabPage"),
                v8::Boolean::New(mode.is_ntp()));
   return context;
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetDisplayInstantResults(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
   bool display_instant_results =
       SearchBox::Get(render_view)->display_instant_results();
   DVLOG(1) << "GetDisplayInstantResults: " << display_instant_results;
   return v8::Boolean::New(display_instant_results);
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetThemeBackgroundInfo(
     const v8::Arguments& args) {
-  DVLOG(1) << "GetThemeBackgroundInfo";
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
+  DVLOG(1) << render_view << " GetThemeBackgroundInfo";
   const ThemeBackgroundInfo& theme_info =
       SearchBox::Get(render_view)->GetThemeBackgroundInfo();
   v8::Handle<v8::Object> info = v8::Object::New();
 
   // The theme background color is in RGBA format "rgba(R,G,B,A)" where R, G and
   // B are between 0 and 255 inclusive, and A is a double between 0 and 1
   // inclusive.
   // This is the CSS "background-color" format.
   // Value is always valid.
   info->Set(v8::String::New("colorRgba"), UTF8ToV8String(
@@ skipping 74 matching lines @@
 
   return info;
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetThemeAreaHeight(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view) return v8::Undefined();
 
-  DVLOG(1) << "GetThemeAreaHeight: "
+  DVLOG(1) << render_view << " GetThemeAreaHeight: "
            << SearchBox::Get(render_view)->GetThemeAreaHeight();
   return v8::Int32::New(SearchBox::Get(render_view)->GetThemeAreaHeight());
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::NavigateContentWindow(
     const v8::Arguments& args) {
   content::RenderView* render_view = GetRenderView();
   if (!render_view || !args.Length()) return v8::Undefined();
 
@@ skipping 12 matching lines @@
     WebKit::WebURLRequest request(destination_url);
     render_view->GetWebView()->mainFrame()->loadRequest(request);
   }
 
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::SetSuggestions(
     const v8::Arguments& args) {
-  DVLOG(1) << "SetSuggestions";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || !args.Length()) return v8::Undefined();
 
+  DVLOG(1) << render_view << " SetSuggestions";
   v8::Handle<v8::Object> suggestion_json = args[0]->ToObject();
 
   InstantCompleteBehavior behavior = INSTANT_COMPLETE_NOW;
   InstantSuggestionType type = INSTANT_SUGGESTION_SEARCH;
   v8::Handle<v8::Value> complete_value =
       suggestion_json->Get(v8::String::New("complete_behavior"));
   if (complete_value->Equals(v8::String::New("now"))) {
     behavior = INSTANT_COMPLETE_NOW;
   } else if (complete_value->Equals(v8::String::New("never"))) {
     behavior = INSTANT_COMPLETE_NEVER;
@@ skipping 15 matching lines @@
   }
 
   SearchBox::Get(render_view)->SetSuggestions(suggestions);
 
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::SetQuerySuggestion(
     const v8::Arguments& args) {
-  DVLOG(1) << "SetQuerySuggestion";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || args.Length() < 2) return v8::Undefined();
 
+  DVLOG(1) << render_view << " SetQuerySuggestion";
   string16 text = V8ValueToUTF16(args[0]);
   InstantCompleteBehavior behavior = INSTANT_COMPLETE_NOW;
   InstantSuggestionType type = INSTANT_SUGGESTION_URL;
 
   if (args[1]->Uint32Value() == 2) {
     behavior = INSTANT_COMPLETE_NEVER;
     type = INSTANT_SUGGESTION_SEARCH;
   }
 
   std::vector<InstantSuggestion> suggestions;
   suggestions.push_back(InstantSuggestion(text, behavior, type));
   SearchBox::Get(render_view)->SetSuggestions(suggestions);
 
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value>
     SearchBoxExtensionWrapper::SetQuerySuggestionFromAutocompleteResult(
         const v8::Arguments& args) {
-  DVLOG(1) << "SetQuerySuggestionFromAutocompleteResult";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || !args.Length()) return v8::Undefined();
 
+  DVLOG(1) << render_view << " SetQuerySuggestionFromAutocompleteResult";
   const InstantAutocompleteResult* result = SearchBox::Get(render_view)->
       GetAutocompleteResultWithId(args[0]->Uint32Value());
   if (!result) return v8::Undefined();
 
   // We only support selecting autocomplete results that are URLs.
   string16 text = result->destination_url;
   InstantCompleteBehavior behavior = INSTANT_COMPLETE_NOW;
   InstantSuggestionType type = INSTANT_SUGGESTION_URL;
 
   std::vector<InstantSuggestion> suggestions;
   suggestions.push_back(InstantSuggestion(text, behavior, type));
   SearchBox::Get(render_view)->SetSuggestions(suggestions);
 
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::SetQuery(
     const v8::Arguments& args) {
-  DVLOG(1) << "SetQuery";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || args.Length() < 2) return v8::Undefined();
 
+  DVLOG(1) << render_view << " SetQuery";
   string16 text = V8ValueToUTF16(args[0]);
   InstantCompleteBehavior behavior = INSTANT_COMPLETE_REPLACE;
   InstantSuggestionType type = INSTANT_SUGGESTION_SEARCH;
 
   if (args[1]->Uint32Value() == 1)
     type = INSTANT_SUGGESTION_URL;
 
   std::vector<InstantSuggestion> suggestions;
   suggestions.push_back(InstantSuggestion(text, behavior, type));
   SearchBox::Get(render_view)->SetSuggestions(suggestions);
 
   return v8::Undefined();
 }
 
 v8::Handle<v8::Value>
     SearchBoxExtensionWrapper::SetQueryFromAutocompleteResult(
         const v8::Arguments& args) {
-  DVLOG(1) << "SetQueryFromAutocompleteResult";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || !args.Length()) return v8::Undefined();
 
+  DVLOG(1) << render_view << " SetQueryFromAutocompleteResult";
   const InstantAutocompleteResult* result = SearchBox::Get(render_view)->
       GetAutocompleteResultWithId(args[0]->Uint32Value());
   if (!result) return v8::Undefined();
 
   // We only support selecting autocomplete results that are URLs.
   string16 text = result->destination_url;
   InstantCompleteBehavior behavior = INSTANT_COMPLETE_REPLACE;
   // TODO(jered): Distinguish between history URLs and search provider
   // navsuggest URLs so that we can do proper accounting on history URLs.
   InstantSuggestionType type = INSTANT_SUGGESTION_URL;
 
   std::vector<InstantSuggestion> suggestions;
   suggestions.push_back(InstantSuggestion(text, behavior, type));
   SearchBox::Get(render_view)->SetSuggestions(suggestions);
 
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::Show(
     const v8::Arguments& args) {
-  DVLOG(1) << "ShowInstantPreview";
   content::RenderView* render_view = GetRenderView();
   if (!render_view || args.Length() < 2) return v8::Undefined();
 
+  DVLOG(1) << render_view << " ShowInstantPreview";
   InstantShownReason reason = INSTANT_SHOWN_NOT_SPECIFIED;
   switch (args[0]->Uint32Value()) {
     case 1: reason = INSTANT_SHOWN_CUSTOM_NTP_CONTENT; break;
     case 2: reason = INSTANT_SHOWN_QUERY_SUGGESTIONS; break;
     case 3: reason = INSTANT_SHOWN_ZERO_SUGGESTIONS; break;
   }
 
   int height = 100;
   InstantSizeUnits units = INSTANT_SIZE_PERCENT;
   if (args[1]->IsInt32()) {
     height = args[1]->Int32Value();
     units = INSTANT_SIZE_PIXELS;
   }
 
   SearchBox::Get(render_view)->ShowInstantPreview(reason, height, units);
 
   return v8::Undefined();
 }
 
 // static
 void SearchBoxExtension::DispatchChange(WebKit::WebFrame* frame) {
-  DVLOG(1) << "DispatchChange";
   Dispatch(frame, kDispatchChangeEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchSubmit(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchSubmitEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchCancel(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchCancelEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchResize(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchResizeEventScript);
 }
 
 // static
 bool SearchBoxExtension::PageSupportsInstant(WebKit::WebFrame* frame) {
   if (!frame) return false;
 
   v8::Handle<v8::Value> v = frame->executeScriptAndReturnValue(
       WebKit::WebScriptSource(kSupportsInstantScript));
-  bool supports_instant = !v.IsEmpty() && v->BooleanValue();
-
-  // Send a resize message to tell the page that Chrome is actively using the
-  // searchbox API with it. The page uses the message to transition from
-  // "homepage" mode to "search" mode.
-  if (supports_instant)
-    DispatchResize(frame);
-
-  DVLOG(1) << "PageSupportsInstant: " << supports_instant;
-  return supports_instant;
+  return !v.IsEmpty() && v->BooleanValue();
 }
 
 // static
 void SearchBoxExtension::DispatchAutocompleteResults(WebKit::WebFrame* frame) {
-  DVLOG(1) << "DispatchAutocompleteResults";
   Dispatch(frame, kDispatchAutocompleteResultsEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchUpOrDownKeyPress(WebKit::WebFrame* frame,
                                                   int count) {
   Dispatch(frame, WebKit::WebString::fromUTF8(
       base::StringPrintf(kDispatchUpOrDownKeyPressEventScript, abs(count),
                          count < 0 ? ui::VKEY_UP : ui::VKEY_DOWN)));
 }
 
 // static
 void SearchBoxExtension::DispatchContextChange(WebKit::WebFrame* frame) {
-  DVLOG(1) << "DispatchContextChange";
   Dispatch(frame, kDispatchContextChangeEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchThemeChange(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchThemeChangeEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchThemeAreaHeightChange(
     WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchThemeAreaHeightChangeEventScript);
 }
 
 // static
 v8::Extension* SearchBoxExtension::Get() {
   return new SearchBoxExtensionWrapper(ResourceBundle::GetSharedInstance().
       GetRawDataResource(IDR_SEARCHBOX_API));
 }
 
 }  // namespace extensions_v8