[content shell] add stubs for all missing WebTestDelegate methods

content/shell/webkit_test_runner.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 "content/shell/webkit_test_runner.h"
 
 #include <cmath>
 
 #include "base/base64.h"
+#include "base/debug/debugger.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stringprintf.h"
 #include "base/sys_string_conversions.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/test/layouttest_support.h"
 #include "content/shell/shell_messages.h"
 #include "content/shell/shell_render_process_observer.h"
 #include "content/shell/webkit_test_helpers.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/Platform.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebRect.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebSize.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURL.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLError.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebURLResponse.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebContextMenuData.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDataSource.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDevToolsAgent.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebDeviceOrientation.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebKit.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 #include "third_party/WebKit/Tools/DumpRenderTree/chromium/TestRunner/public/WebTask.h"
 #include "third_party/WebKit/Tools/DumpRenderTree/chromium/TestRunner/public/WebTestProxy.h"
 #include "webkit/base/file_path_string_conversions.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webpreferences.h"
 
 using WebKit::Platform;
 using WebKit::WebContextMenuData;
 using WebKit::WebDevToolsAgent;
+using WebKit::WebDeviceOrientation;
 using WebKit::WebElement;
 using WebKit::WebFrame;
 using WebKit::WebGamepads;
 using WebKit::WebRect;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebVector;
 using WebKit::WebView;
@@ skipping 91 matching lines @@
 
 #if !defined(OS_MACOSX)
   // Only the expected PNGs for Mac have a valid alpha channel.
   MakeBitmapOpaque(snapshot);
 #endif
 
 }
 
 }  // namespace
 
+// static
+int WebKitTestRunner::window_count_ = 0;
+
 WebKitTestRunner::WebKitTestRunner(RenderView* render_view)
     : RenderViewObserver(render_view) {
   Reset();
+  ++window_count_;
 }
 
 WebKitTestRunner::~WebKitTestRunner() {
+  --window_count_;
 }
 
 // WebTestDelegate  -----------------------------------------------------------
 
-void WebKitTestRunner::clearContextMenuData() {
-  last_context_menu_data_.reset();
-}
-
-WebContextMenuData* WebKitTestRunner::lastContextMenuData() const {
-  return last_context_menu_data_.get();
-}
-
 void WebKitTestRunner::clearEditCommand() {
   render_view()->ClearEditCommands();
 }
 
 void WebKitTestRunner::setEditCommand(const std::string& name,
                                       const std::string& value) {
   render_view()->SetEditCommandForNextKeyEvent(name, value);
 }
 
-void WebKitTestRunner::fillSpellingSuggestionList(
-    const WebString& word, WebVector<WebString>* suggestions) {
-  if (word == WebString::fromUTF8("wellcome")) {
-      WebVector<WebString> result(suggestions->size() + 1);
-      for (size_t i = 0; i < suggestions->size(); ++i)
-        result[i] = (*suggestions)[i];
-      result[suggestions->size()] = WebString::fromUTF8("welcome");
-      suggestions->swap(result);
-  }
-}
-
 void WebKitTestRunner::setGamepadData(const WebGamepads& gamepads) {
   SetMockGamepads(gamepads);
 }
 
 void WebKitTestRunner::printMessage(const std::string& message) {
   Send(new ShellViewHostMsg_PrintMessage(routing_id(), message));
 }
 
 void WebKitTestRunner::postTask(WebTask* task) {
   Platform::current()->callOnMainThread(InvokeTaskHelper, task);
@@ skipping 111 matching lines @@
       break;
     }
   } else {
     DLOG(WARNING) << "Unknown error domain";
   }
 
   return base::StringPrintf("<NSError domain %s, code %d, failing URL \"%s\">",
       domain.c_str(), code, error.unreachableURL.spec().data());
 }
 
+void WebKitTestRunner::setClientWindowRect(const WebRect& rect) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setClientWindowRect"));
+}
+
+void WebKitTestRunner::showDevTools() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "showDevTools"));
+}
+
+void WebKitTestRunner::closeDevTools() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "closeDevTools"));
+}
+
+void WebKitTestRunner::evaluateInWebInspector(long call_id,
+                                              const std::string& script) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "evaluateInWebInspector"));
+}
+
+void WebKitTestRunner::clearAllDatabases() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "clearAllDatabases"));
+}
+
+void WebKitTestRunner::setDatabaseQuota(int quota) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setDatabaseQuota"));
+}
+
+void WebKitTestRunner::setDeviceScaleFactor(float factor) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setDeviceScaleFactor"));
+}
+
+void WebKitTestRunner::setFocus(bool focus) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setFocus"));
+}
+
+void WebKitTestRunner::setAcceptAllCookies(bool accept) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setAcceptAllCookies"));
+}
+
+std::string WebKitTestRunner::pathToLocalResource(const std::string& resource) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "pathToLocalResource"));
+  return std::string();
+}
+
+void WebKitTestRunner::setLocale(const std::string& locale) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setLocale"));
+}
+
+void WebKitTestRunner::setDeviceOrientation(WebDeviceOrientation& orientation) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setDeviceOrientation"));
+}
+
+void WebKitTestRunner::didAcquirePointerLock() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "didAcquirePointerLock"));
+}
+
+void WebKitTestRunner::didNotAcquirePointerLock() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "didNotAcquirePointerLock"));
+}
+
+void WebKitTestRunner::didLosePointerLock() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "didLosePointerLock"));
+}
+
+void WebKitTestRunner::setPointerLockWillRespondAsynchronously() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(),
+      "WebKitTestRunner",
+      "setPointerLockWillRespondAsynchronously"));
+}
+
+void WebKitTestRunner::setPointerLockWillFailSynchronously() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setPointerLockWillFailSynchronously"));
+}
+
+int WebKitTestRunner::numberOfPendingGeolocationPermissionRequests() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(),
+      "WebKitTestRunner",
+      "numberOfPendingGeolocationPermissionRequests"));
+  return 0;
+}
+
+void WebKitTestRunner::setGeolocationPermission(bool allowed) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setGeolocationPermission"));
+}
+
+void WebKitTestRunner::setMockGeolocationPosition(double latitude,
+                                                  double longitude,
+                                                  double precision) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setMockGeolocationPosition"));
+}
+
+void WebKitTestRunner::setMockGeolocationPositionUnavailableError(
+    const std::string& message) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(),
+      "WebKitTestRunner",
+      "setMockGeolocationPositionUnavailableError"));
+}
+
+void WebKitTestRunner::addMockSpeechInputResult(const std::string& result,
+                                                double confidence,
+                                                const std::string& language) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "addMockSpeechInputResult"));
+}
+
+void WebKitTestRunner::setMockSpeechInputDumpRect(bool dump_rect) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setMockSpeechInputDumpRect"));
+}
+
+void WebKitTestRunner::addMockSpeechRecognitionResult(
+    const std::string& transcript,
+    double confidence) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "addMockSpeechRecognitionResult"));
+}
+
+void WebKitTestRunner::setMockSpeechRecognitionError(
+    const std::string& error,
+    const std::string& message) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "setMockSpeechRecognitionError"));
+}
+
+bool WebKitTestRunner::wasMockSpeechRecognitionAborted() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "wasMockSpeechRecognitionAborted"));
+  return false;
+}
+
+void WebKitTestRunner::testFinished() {
+  CaptureDump();
+}
+
+void WebKitTestRunner::testTimedOut() {
+  Send(new ShellViewHostMsg_TestFinished(routing_id(), true));
+}
+
+bool WebKitTestRunner::isBeingDebugged() {
+  return base::debug::BeingDebugged();
+}
+
+int WebKitTestRunner::layoutTestTimeout() {
+  return layout_test_timeout_;
+}
+
+void WebKitTestRunner::closeRemainingWindows() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "closeRemainingWindows"));
+}
+
+int WebKitTestRunner::navigationEntryCount() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "navigationEntryCount"));
+  return 0;
+}
+
+int WebKitTestRunner::windowCount() {
+  return window_count_;
+}
+
+void WebKitTestRunner::goToOffset(int offset) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "goToOffset"));
+}
+
+void WebKitTestRunner::reload() {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "reload"));
+}
+
+void WebKitTestRunner::loadURLForFrame(const WebURL& url,
+                             const std::string& frame_name) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "loadURLForFrame"));
+}
+
+bool WebKitTestRunner::allowExternalPages() {
+  return allow_external_pages_;
+}
+
+void WebKitTestRunner::captureHistoryForWindow(
+    size_t windowIndex,
+    WebVector<WebKit::WebHistoryItem>* history,
+    size_t* currentEntryIndex) {
+  Send(new ShellViewHostMsg_NotImplemented(
+      routing_id(), "WebKitTestRunner", "captureHistoryForWindow"));
+}
+
 // RenderViewObserver  --------------------------------------------------------
 
 void WebKitTestRunner::DidClearWindowObject(WebFrame* frame) {
   ShellRenderProcessObserver::GetInstance()->BindTestRunnersToWindow(frame);
 }
 
 void WebKitTestRunner::DidFinishLoad(WebFrame* frame) {
   if (!frame->parent()) {
     if (!wait_until_done_) {
       test_is_running_ = false;
       CaptureDump();
     }
     load_finished_ = true;
   }
 }
 
-void WebKitTestRunner::DidRequestShowContextMenu(
-    WebFrame* frame,
-    const WebContextMenuData& data) {
-  last_context_menu_data_.reset(new WebContextMenuData(data));
-}
-
 bool WebKitTestRunner::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(WebKitTestRunner, message)
     IPC_MESSAGE_HANDLER(ShellViewMsg_SetTestConfiguration,
                         OnSetTestConfiguration)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   return handled;
 }
@@ skipping 141 matching lines @@
     bool allow_external_pages,
     const std::string& expected_pixel_hash) {
   current_working_directory_ = current_working_directory;
   enable_pixel_dumping_ = enable_pixel_dumping;
   layout_test_timeout_ = layout_test_timeout;
   allow_external_pages_ = allow_external_pages;
   expected_pixel_hash_ = expected_pixel_hash;
 }
 
 }  // namespace content