Instant extended API: Make arrow up/down work.

chrome/renderer/searchbox/searchbox_extension.cc

 // Copyright (c) 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 <ctype.h>
-#include <vector>
 
 #include "base/string_number_conversions.h"
-#include "base/string_piece.h"
-#include "base/string_util.h"
+#include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/renderer/searchbox/searchbox.h"
 #include "content/public/renderer/render_view.h"
 #include "grit/renderer_resources.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebScriptSource.h"
-#include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
+#include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "v8/include/v8.h"
 
 namespace {
 
 // Splits the string in |number| into two pieces, a leading number token (saved
 // in |number|) and the rest (saved in |suffix|). Either piece may become empty,
 // depending on whether the input had no digits or only digits. Neither argument
 // may be NULL.
 void SplitLeadingNumberToken(std::string* number, std::string* suffix) {
@@ skipping 71 matching lines @@
 // Extended API.
 static const char kDispatchAutocompleteResultsEventScript[] =
     "if (window.chrome &&"
     "    window.chrome.searchBox &&"
     "    window.chrome.searchBox.onnativesuggestions &&"
     "    typeof window.chrome.searchBox.onnativesuggestions == 'function') {"
     "  window.chrome.searchBox.onnativesuggestions();"
     "  true;"
     "}";
 
-static const char kDispatchKeyPressEventScript[] =
+// Takes two printf-style replaceable values: count, key_code.
+static const char kDispatchUpOrDownKeyPressEventScript[] =
     "if (window.chrome &&"
     "    window.chrome.searchBox &&"
     "    window.chrome.searchBox.onkeypress &&"
     "    typeof window.chrome.searchBox.onkeypress == 'function') {"
-    "  window.chrome.searchBox.onkeypress("
-    "      {keyCode:window.chrome.searchBox.keyCode});"
+    "  for (var i = 0; i < %d; ++i)"
+    "    window.chrome.searchBox.onkeypress({keyCode: %d});"
     "  true;"
     "}";
 
 // ----------------------------------------------------------------------------
 
 class SearchBoxExtensionWrapper : public v8::Extension {
  public:
   explicit SearchBoxExtensionWrapper(const base::StringPiece& code);
 
   // Allows v8's javascript code to call the native functions defined
@@ skipping 29 matching lines @@
   // Gets the width of the region of the search box that overlaps the window.
   static v8::Handle<v8::Value> GetWidth(const v8::Arguments& args);
 
   // Gets the height of the region of the search box that overlaps the window.
   static v8::Handle<v8::Value> GetHeight(const v8::Arguments& args);
 
   // Gets the autocomplete results from search box.
   static v8::Handle<v8::Value> GetAutocompleteResults(
       const v8::Arguments& args);
 
-  // Gets the last key code entered in search box.
-  static v8::Handle<v8::Value> GetKeyCode(const v8::Arguments& args);
-
   // Sets ordered suggestions. Valid for current |value|.
   static v8::Handle<v8::Value> SetSuggestions(const v8::Arguments& args);
 
   // Sets the text to be autocompleted into the search box.
   static v8::Handle<v8::Value> SetQuerySuggestion(const v8::Arguments& args);
 
   // Like |SetQuerySuggestion| but uses a restricted ID to identify the text.
   static v8::Handle<v8::Value> SetQuerySuggestionFromAutocompleteResult(
       const v8::Arguments& args);
 
@@ skipping 29 matching lines @@
   } else if (name->Equals(v8::String::New("GetX"))) {
     return v8::FunctionTemplate::New(GetX);
   } else if (name->Equals(v8::String::New("GetY"))) {
     return v8::FunctionTemplate::New(GetY);
   } else if (name->Equals(v8::String::New("GetWidth"))) {
     return v8::FunctionTemplate::New(GetWidth);
   } else if (name->Equals(v8::String::New("GetHeight"))) {
     return v8::FunctionTemplate::New(GetHeight);
   } else if (name->Equals(v8::String::New("GetAutocompleteResults"))) {
     return v8::FunctionTemplate::New(GetAutocompleteResults);
-  } else if (name->Equals(v8::String::New("GetKeyCode"))) {
-    return v8::FunctionTemplate::New(GetKeyCode);
   } else if (name->Equals(v8::String::New("SetSuggestions"))) {
     return v8::FunctionTemplate::New(SetSuggestions);
   } else if (name->Equals(v8::String::New("SetQuerySuggestion"))) {
     return v8::FunctionTemplate::New(SetQuerySuggestion);
   } else if (name->Equals(v8::String::New(
       "SetQuerySuggestionFromAutocompleteResult"))) {
     return v8::FunctionTemplate::New(SetQuerySuggestionFromAutocompleteResult);
   } else if (name->Equals(v8::String::New("SetQuery"))) {
     return v8::FunctionTemplate::New(SetQuery);
   } else if (name->Equals(v8::String::New("SetQueryFromAutocompleteResult"))) {
@@ skipping 105 matching lines @@
                       v8::Int32::New(results[i].relevance));
     result->Set(v8::String::New("rankingData"), ranking_data);
 
     results_array->Set(i, result);
   }
 
   return results_array;
 }
 
 // static
-v8::Handle<v8::Value> SearchBoxExtensionWrapper::GetKeyCode(
-    const v8::Arguments& args) {
-  content::RenderView* render_view = GetRenderView();
-  if (!render_view) return v8::Undefined();
-  return v8::Int32::New(SearchBox::Get(render_view)->key_code());
-}
-
-// static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::SetSuggestions(
     const v8::Arguments& args) {
   std::vector<InstantSuggestion> suggestions;
 
   if (args.Length() && args[0]->IsObject()) {
     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 =
@@ skipping 95 matching lines @@
       VLOG(1) << "Invalid results_id " << results_id << "; "
               << "results_base is " << results_base << ".";
     }
   }
   return v8::Undefined();
 }
 
 // static
 v8::Handle<v8::Value> SearchBoxExtensionWrapper::SetQuery(
     const v8::Arguments& args) {
-  // TODO(sreeram): Make the second argument (type) mandatory.
   if (1 <= args.Length() && args.Length() <= 2 && args[0]->IsString()) {
     string16 text = V8ValueToUTF16(args[0]);
     InstantCompleteBehavior behavior = INSTANT_COMPLETE_REPLACE;
-    InstantSuggestionType type = INSTANT_SUGGESTION_SEARCH;
+    InstantSuggestionType type = INSTANT_SUGGESTION_URL;
 
-    if (args.Length() >= 2 && args[1]->Uint32Value() == 1)
-      type = INSTANT_SUGGESTION_URL;
+    if (args.Length() >= 2 && args[1]->Uint32Value() == 0)
+      type = INSTANT_SUGGESTION_SEARCH;
 
     if (content::RenderView* render_view = GetRenderView()) {
       std::vector<InstantSuggestion> suggestions;
       suggestions.push_back(InstantSuggestion(text, behavior, type));
       SearchBox::Get(render_view)->SetSuggestions(suggestions);
     }
   }
   return v8::Undefined();
 }
 
@@ skipping 55 matching lines @@
       return v8::Undefined();
     }
     content::RenderView* render_view = GetRenderView();
     if (render_view && height >= 0)
       SearchBox::Get(render_view)->SetInstantPreviewHeight(height, units);
   }
   return v8::Undefined();
 }
 
 // static
-void Dispatch(WebKit::WebFrame* frame, WebKit::WebString script) {
+void Dispatch(WebKit::WebFrame* frame, const WebKit::WebString& script) {
   DCHECK(frame) << "Dispatch requires frame";
   if (!frame) return;
   frame->executeScript(WebKit::WebScriptSource(script));
 }
 
 // static
 void SearchBoxExtension::DispatchChange(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchChangeEventScript);
 }
 
@@ skipping 11 matching lines @@
 void SearchBoxExtension::DispatchResize(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchResizeEventScript);
 }
 
 // static
 void SearchBoxExtension::DispatchAutocompleteResults(WebKit::WebFrame* frame) {
   Dispatch(frame, kDispatchAutocompleteResultsEventScript);
 }
 
 // static
-void SearchBoxExtension::DispatchKeyPress(WebKit::WebFrame* frame) {
-  Dispatch(frame, kDispatchKeyPressEventScript);
+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
 bool SearchBoxExtension::PageSupportsInstant(WebKit::WebFrame* frame) {
   DCHECK(frame) << "PageSupportsInstant requires 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);
 
   return supports_instant;
 }
 
 // static
 v8::Extension* SearchBoxExtension::Get() {
   const base::StringPiece code =
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_SEARCHBOX_API, ui::SCALE_FACTOR_NONE);
   return new SearchBoxExtensionWrapper(code);
 }
 
 }  // namespace extensions_v8