Switch to using the message loop rather than gtk_main().

Include more code from the main test_shell.cc into the GTK version. Wherever
possible the code has been copied and pasted in directly to make the future
merge easy.

Review URL: http://codereview.chromium.org/8670


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@4255 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 916 insertions, 9 deletions

diff --git a/base/logging.h b/base/logging.h
index 95cbfac..5fa5681 100644
--- a/base/logging.h
+++ b/base/logging.h
@@ -513,6 +513,14 @@ inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
 #define NOTIMPLEMENTED_POLICY 4
 #endif
 
+#if defined(COMPILER_GCC)
+// On Linux, with GCC, we can use __PRETTY_FUNCTION__ to get the demangled name
+// of the current function in the NOTIMPLEMENTED message.
+#define NOTIMPLEMENTED_MSG "Not implemented reached in " << __PRETTY_FUNCTION__
+#else
+#define NOTIMPLEMENTED_MSG "NOT IMPLEMENTED"
+#endif
+
 #if NOTIMPLEMENTED_POLICY == 0
 #define NOTIMPLEMENTED() ;
 #elif NOTIMPLEMENTED_POLICY == 1
@@ -523,11 +531,11 @@ inline std::ostream& operator<<(std::ostream& out, const std::wstring& wstr) {
 #elif NOTIMPLEMENTED_POLICY == 3
 #define NOTIMPLEMENTED() NOTREACHED()
 #elif NOTIMPLEMENTED_POLICY == 4
-#define NOTIMPLEMENTED() LOG(ERROR) << "NOT IMPLEMENTED!"
+#define NOTIMPLEMENTED() LOG(ERROR) << NOTIMPLEMENTED_MSG
 #elif NOTIMPLEMENTED_POLICY == 5
 #define NOTIMPLEMENTED() do {\
   static int count = 0;\
-  LOG_IF(ERROR, 0 == count++) << "NOT IMPLEMENTED!";\
+  LOG_IF(ERROR, 0 == count++) << NOTIMPLEMENTED_MSG;\
 } while(0)
 #endif
 
diff --git a/webkit/glue/webkit_glue.cc b/webkit/glue/webkit_glue.cc
index e59bd68..1c5d0fd 100644
--- a/webkit/glue/webkit_glue.cc
+++ b/webkit/glue/webkit_glue.cc
@@ -403,6 +403,15 @@ void SetUserAgentToDefault() {
       WEBKIT_VERSION_MAJOR,
       WEBKIT_VERSION_MINOR
       );
+#elif defined(OS_LINUX)
+  // TODO(agl): We don't have version information embedded in files under Linux
+  // so we use the following string which is based off the UA string for
+  // Windows. Some solution for embedding the Chrome version number needs to be
+  // found here.
+  StringAppendF(
+      &default_user_agent,
+      "Mozilla/5.0 (Linux; U; en-US) AppleWebKit/525.13 "
+      "(KHTML, like Gecko) Chrome/0.2.149.27 Safari/525.13");
 #else
   // TODO(port): we need something like FileVersionInfo for our UA string.
   NOTIMPLEMENTED();
diff --git a/webkit/tools/test_shell/SConscript b/webkit/tools/test_shell/SConscript
index 70c9260..92e9d0d 100644
--- a/webkit/tools/test_shell/SConscript
+++ b/webkit/tools/test_shell/SConscript
@@ -93,6 +93,7 @@ elif env['PLATFORM'] in ('posix', 'darwin'):
   )
 
 input_files = [
+    'layout_test_controller.cc',
     'simple_resource_loader_bridge.cc',
     'test_navigation_controller.cc',
     'test_shell_request_context.cc',
@@ -104,7 +105,6 @@ if env['PLATFORM'] == 'win32':
       'drag_delegate.cc',
       'drop_delegate.cc',
       'event_sending_controller.cc',
-      'layout_test_controller.cc',
       'test_shell.cc',
       'test_shell_win.cc',
       'test_webview_delegate.cc',
@@ -117,6 +117,7 @@ elif env['PLATFORM'] == 'posix':
       'gtk/test_shell.cc',
       'gtk/webwidget_host.cc',
       'gtk/webview_host.cc',
+      'gtk/test_webview_delegate.cc',
   ])
 
 lib = env.ChromeStaticLibrary('test_shell', input_files)
@@ -153,6 +154,7 @@ if env['PLATFORM'] == 'win32':
 test_files = [
     'image_decoder_unittest.cc',
     'run_all_tests.cc',
+    'layout_test_controller_unittest.cc',
     '$WEBKIT_DIR/glue/autocomplete_input_listener_unittest.cc',
     '$WEBKIT_DIR/glue/cpp_variant_unittest.cc',
     '$WEBKIT_DIR/glue/glue_serialize_unittest.cc',
@@ -167,7 +169,6 @@ if env['PLATFORM'] == 'win32':
   # TODO(port): put portable files in above test_files declaration.
   test_files.extend([
       'keyboard_unittest.cc',
-      'layout_test_controller_unittest.cc',
       'node_leak_test.cc',
       'plugin_tests.cc',
       'run_all_tests.cc',
diff --git a/webkit/tools/test_shell/gtk/test_shell.cc b/webkit/tools/test_shell/gtk/test_shell.cc
index 97dc66c..c048f04 100644
--- a/webkit/tools/test_shell/gtk/test_shell.cc
+++ b/webkit/tools/test_shell/gtk/test_shell.cc
@@ -10,26 +10,34 @@
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "net/base/mime_util.h"
+#include "webkit/glue/webframe.h"
 #include "webkit/glue/webpreferences.h"
+#include "webkit/glue/webview.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/resource_loader_bridge.h"
 #include "webkit/tools/test_shell/test_navigation_controller.h"
+#include "webkit/tools/test_shell/test_webview_delegate.h"
 
 WebPreferences* TestShell::web_prefs_ = NULL;
 
 WindowList* TestShell::window_list_;
 
-TestShell::TestShell() {
+TestShell::TestShell()
+    : delegate_(new TestWebViewDelegate(this)) {
+  layout_test_controller_.reset(new LayoutTestController(this));
+  navigation_controller_.reset(new TestNavigationController(this));
 }
 
 TestShell::~TestShell() {
 }
 
+bool TestShell::interactive_ = false;
+
 // static
 void TestShell::InitializeTestShell(bool interactive) {
   window_list_ = new WindowList;
-
   web_prefs_ = new WebPreferences;
+  interactive_ = interactive;
 }
 
 // static
@@ -78,21 +86,116 @@ bool TestShell::Initialize(const std::wstring& startingURL) {
   gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
   m_webViewHost.reset(WebViewHost::Create(vbox, NULL, *TestShell::web_prefs_));
 
+  if (!startingURL.empty())
+    LoadURL(startingURL.c_str());
+
   gtk_container_add(GTK_CONTAINER(m_mainWnd), vbox);
   gtk_widget_show_all(m_mainWnd);
 
   return true;
 }
 
+void TestShell::TestFinished() {
+  NOTIMPLEMENTED();
+}
+
+void TestShell::Show(WebView* webview, WindowOpenDisposition disposition) {
+  delegate_->Show(webview, disposition);
+}
+
+void TestShell::SetFocus(WebWidgetHost* host, bool enable) {
+  // TODO(agl): port the body of this function
+  NOTIMPLEMENTED();
+}
+
 void TestShell::BindJSObjectsToWindow(WebFrame* frame) {
   NOTIMPLEMENTED();
 }
 
-bool TestShell::Navigate(const TestNavigationEntry& entry, bool reload) {
+void TestShell::DestroyWindow(gfx::WindowHandle windowHandle) {
+  NOTIMPLEMENTED();
+}
+
+WebView* TestShell::CreateWebView(WebView* webview) {
+  NOTIMPLEMENTED();
+  return NULL;
+}
+
+WebWidget* TestShell::CreatePopupWidget(WebView* webview) {
   NOTIMPLEMENTED();
+  return NULL;
+}
+
+void TestShell::LoadURL(const wchar_t* url)
+{
+    LoadURLForFrame(url, NULL);
+}
+
+void TestShell::LoadURLForFrame(const wchar_t* url,
+                                const wchar_t* frame_name) {
+    if (!url)
+        return;
+
+    std::wstring frame_string;
+    if (frame_name)
+        frame_string = frame_name;
+
+    navigation_controller_->LoadEntry(new TestNavigationEntry(
+        -1, GURL(WideToUTF8(url)), std::wstring(), frame_string));
+}
+
+bool TestShell::Navigate(const TestNavigationEntry& entry, bool reload) {
+  WebRequestCachePolicy cache_policy;
+  if (reload) {
+    cache_policy = WebRequestReloadIgnoringCacheData;
+  } else if (entry.GetPageID() != -1) {
+    cache_policy = WebRequestReturnCacheDataElseLoad;
+  } else {
+    cache_policy = WebRequestUseProtocolCachePolicy;
+  }
+
+  scoped_ptr<WebRequest> request(WebRequest::Create(entry.GetURL()));
+  request->SetCachePolicy(cache_policy);
+  // If we are reloading, then WebKit will use the state of the current page.
+  // Otherwise, we give it the state to navigate to.
+  if (!reload)
+    request->SetHistoryState(entry.GetContentState());
+    
+  request->SetExtraData(
+      new TestShellExtraRequestData(entry.GetPageID()));
+
+  // Get the right target frame for the entry.
+  WebFrame* frame = webView()->GetMainFrame();
+  if (!entry.GetTargetFrame().empty())
+      frame = webView()->GetFrameWithName(entry.GetTargetFrame());
+  // TODO(mpcomplete): should we clear the target frame, or should
+  // back/forward navigations maintain the target frame?
+
+  frame->LoadRequest(request.get());
+  // Restore focus to the main frame prior to loading new request.
+  // This makes sure that we don't have a focused iframe. Otherwise, that
+  // iframe would keep focus when the SetFocus called immediately after
+  // LoadRequest, thus making some tests fail (see http://b/issue?id=845337
+  // for more details).
+  webView()->SetFocusedFrame(frame);
+  SetFocus(webViewHost(), true);
+
   return true;
 }
 
+void TestShell::GoBackOrForward(int offset) {
+    navigation_controller_->GoToOffset(offset);
+}
+
+void TestShell::Reload() {
+    navigation_controller_->Reload();
+}
+
+std::string TestShell::RewriteLocalUrl(const std::string& url) {
+  NOTIMPLEMENTED();
+  return "";
+}
+
 //-----------------------------------------------------------------------------
 
 namespace webkit_glue {
diff --git a/webkit/tools/test_shell/gtk/test_webview_delegate.cc b/webkit/tools/test_shell/gtk/test_webview_delegate.cc
new file mode 100644
index 0000000..739b459
--- /dev/null
+++ b/webkit/tools/test_shell/gtk/test_webview_delegate.cc
@@ -0,0 +1,780 @@
+// Copyright (c) 2008 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.
+
+// This file was forked off the Mac port.
+
+#include "webkit/tools/test_shell/test_webview_delegate.h"
+
+#include "base/gfx/point.h"
+#include "base/string_util.h"
+#include "net/base/net_errors.h"
+#include "chrome/common/page_transition_types.h"
+#include "webkit/glue/webdatasource.h"
+#include "webkit/glue/webdropdata.h"
+#include "webkit/glue/weberror.h"
+#include "webkit/glue/webframe.h"
+#include "webkit/glue/webpreferences.h"
+#include "webkit/glue/weburlrequest.h"
+#include "webkit/glue/webkit_glue.h"
+#include "webkit/glue/webview.h"
+#include "webkit/glue/window_open_disposition.h"
+#include "webkit/tools/test_shell/test_navigation_controller.h"
+#include "webkit/tools/test_shell/test_shell.h"
+
+static int32 next_page_id_ = 1;
+
+// WebViewDelegate -----------------------------------------------------------
+
+TestWebViewDelegate::~TestWebViewDelegate() {
+}
+
+WebView* TestWebViewDelegate::CreateWebView(WebView* webview,
+                                            bool user_gesture) {
+  return shell_->CreateWebView(webview);
+}
+
+WebWidget* TestWebViewDelegate::CreatePopupWidget(WebView* webview) {
+  return shell_->CreatePopupWidget(webview);
+}
+
+WebPluginDelegate* TestWebViewDelegate::CreatePluginDelegate(
+    WebView* webview,
+    const GURL& url,
+    const std::string& mime_type,
+    const std::string& clsid,
+    std::string* actual_mime_type) {
+  return NULL;
+}
+
+void TestWebViewDelegate::OpenURL(WebView* webview, const GURL& url,
+                                  const GURL&, // TODO(eroman): use referrer
+                                  WindowOpenDisposition disposition) {
+  DCHECK_NE(disposition, CURRENT_TAB);  // No code for this
+  if (disposition == SUPPRESS_OPEN)
+    return;
+  TestShell* shell = NULL;
+  if (TestShell::CreateNewWindow(UTF8ToWide(url.spec()), &shell))
+    shell->Show(shell->webView(), disposition);
+}
+
+void TestWebViewDelegate::DidStartLoading(WebView* webview) {
+  if (page_is_loading_) {
+    LOG(ERROR) << "DidStartLoading called while loading";
+    return;
+  }
+  page_is_loading_ = true;
+}
+
+void TestWebViewDelegate::DidStopLoading(WebView* webview) {
+  if (!page_is_loading_) {
+    LOG(ERROR) << "DidStopLoading called while not loading";
+    return;
+  }
+  page_is_loading_ = false;
+}
+
+void TestWebViewDelegate::WindowObjectCleared(WebFrame* webframe) {
+  shell_->BindJSObjectsToWindow(webframe);
+}
+
+WindowOpenDisposition TestWebViewDelegate::DispositionForNavigationAction(
+    WebView* webview,
+    WebFrame* frame,
+    const WebRequest* request,
+    WebNavigationType type,
+    WindowOpenDisposition disposition,
+    bool is_redirect) {
+  if (is_custom_policy_delegate_) {
+    std::wstring frame_name = frame->GetName();
+    printf("Policy delegate: attempt to load %s\n",
+           request->GetURL().spec().c_str());
+    return IGNORE_ACTION;
+  } else {
+    return static_cast<WindowOpenDisposition>(
+        WebViewDelegate::DispositionForNavigationAction(webview, frame, request,
+                                                        type, disposition,
+                                                        is_redirect));
+  }
+}
+
+void TestWebViewDelegate::SetCustomPolicyDelegate(bool isCustom) {
+  is_custom_policy_delegate_ = isCustom;
+}
+
+void TestWebViewDelegate::AssignIdentifierToRequest(WebView* webview,
+                                                    uint32 identifier,
+                                                    const WebRequest& request) {
+  if (shell_->ShouldDumpResourceLoadCallbacks()) {
+    resource_identifier_map_[identifier] = request.GetURL().spec();
+  }
+}
+
+std::string TestWebViewDelegate::GetResourceDescription(uint32 identifier) {
+  ResourceMap::iterator it = resource_identifier_map_.find(identifier);
+  return it != resource_identifier_map_.end() ? it->second : "<unknown>";
+}
+
+void TestWebViewDelegate::WillSendRequest(WebView* webview,
+                                          uint32 identifier,
+                                          WebRequest* request) {
+  std::string request_url = request->GetURL().spec();
+
+  if (shell_->ShouldDumpResourceLoadCallbacks()) {
+    printf("%s - willSendRequest <WebRequest URL \"%s\">\n",
+           GetResourceDescription(identifier).c_str(),
+           request_url.c_str());
+  }
+
+  // Set the new substituted URL.
+  request->SetURL(GURL(TestShell::RewriteLocalUrl(request_url)));
+}
+
+void TestWebViewDelegate::DidFinishLoading(WebView* webview,
+                                           uint32 identifier) {
+  if (shell_->ShouldDumpResourceLoadCallbacks()) {
+    printf("%s - didFinishLoading\n",
+           GetResourceDescription(identifier).c_str());
+  }
+
+  resource_identifier_map_.erase(identifier);
+}
+
+void TestWebViewDelegate::DidFailLoadingWithError(WebView* webview,
+                                                  uint32 identifier,
+                                                  const WebError& error) {
+  if (shell_->ShouldDumpResourceLoadCallbacks()) {
+    printf("%s - didFailLoadingWithError <WebError code %d,"
+           " failing URL \"%s\">\n",
+           GetResourceDescription(identifier).c_str(),
+           error.GetErrorCode(),
+           error.GetFailedURL().spec().c_str());
+  }
+
+  resource_identifier_map_.erase(identifier);
+}
+
+void TestWebViewDelegate::DidStartProvisionalLoadForFrame(
+    WebView* webview,
+    WebFrame* frame,
+    NavigationGesture gesture) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didStartProvisionalLoadForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  if (!top_loading_frame_) {
+    top_loading_frame_ = frame;
+  }
+  UpdateAddressBar(webview);
+}
+
+void TestWebViewDelegate::DidReceiveServerRedirectForProvisionalLoadForFrame(
+    WebView* webview,
+    WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didReceiveServerRedirectForProvisionalLoadForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  UpdateAddressBar(webview);
+}
+
+void TestWebViewDelegate::DidFailProvisionalLoadWithError(
+    WebView* webview,
+    const WebError& error,
+    WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didFailProvisionalLoadWithError\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  if (page_is_loading_)
+    DidStopLoading(webview);
+  LocationChangeDone(frame->GetProvisionalDataSource());
+
+  // Don't display an error page if we're running layout tests, because
+  // DumpRenderTree doesn't.
+  if (!shell_->interactive())
+    return;
+
+  // Don't display an error page if this is simply a cancelled load.  Aside
+  // from being dumb, WebCore doesn't expect it and it will cause a crash.
+  if (error.GetErrorCode() == net::ERR_ABORTED)
+    return;
+
+  const WebRequest& failed_request =
+      frame->GetProvisionalDataSource()->GetRequest();
+  TestShellExtraRequestData* extra_data =
+      static_cast<TestShellExtraRequestData*>(failed_request.GetExtraData());
+  bool replace = extra_data && extra_data->pending_page_id != -1;
+
+  scoped_ptr<WebRequest> request(failed_request.Clone());
+  request->SetURL(GURL("testshell-error:"));
+
+  std::string error_text =
+      StringPrintf("Error loading url: %d", error.GetErrorCode());
+
+  frame->LoadAlternateHTMLString(request.get(), error_text,
+                                 error.GetFailedURL(), replace);
+}
+
+void TestWebViewDelegate::DidCommitLoadForFrame(WebView* webview,
+                                                WebFrame* frame,
+                                                bool is_new_navigation) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didCommitLoadForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  UpdateForCommittedLoad(frame, is_new_navigation);
+}
+
+void TestWebViewDelegate::DidReceiveTitle(WebView* webview,
+                                          const std::wstring& title,
+                                          WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didReceiveTitle\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  if (shell_->ShouldDumpTitleChanges()) {
+    printf("TITLE CHANGED: %S\n", title.c_str());
+  }
+  NOTIMPLEMENTED();
+}
+
+void TestWebViewDelegate::DidFinishLoadForFrame(WebView* webview,
+                                                WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didFinishLoadForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  UpdateAddressBar(webview);
+  LocationChangeDone(frame->GetDataSource());
+}
+
+void TestWebViewDelegate::DidFailLoadWithError(WebView* webview,
+                                               const WebError& error,
+                                               WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didFailLoadWithError\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  if (page_is_loading_)
+    DidStopLoading(webview);
+  LocationChangeDone(frame->GetDataSource());
+}
+
+void TestWebViewDelegate::DidFinishDocumentLoadForFrame(WebView* webview,
+                                                        WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didFinishDocumentLoadForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+}
+
+void TestWebViewDelegate::DidHandleOnloadEventsForFrame(WebView* webview,
+                                                        WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didHandleOnloadEventsForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+}
+
+void TestWebViewDelegate::DidChangeLocationWithinPageForFrame(
+    WebView* webview, WebFrame* frame, bool is_new_navigation) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didChangeLocationWithinPageForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+
+  UpdateForCommittedLoad(frame, is_new_navigation);
+}
+
+void TestWebViewDelegate::DidReceiveIconForFrame(WebView* webview,
+                                                 WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didReceiveIconForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+}
+
+void TestWebViewDelegate::WillPerformClientRedirect(
+    WebView* webview, WebFrame* frame, const std::wstring& dest_url,
+    unsigned int delay_seconds, unsigned int fire_date) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    // TODO: prettyprint the url?
+    printf("%S - willPerformClientRedirectToURL: %S\n",
+           GetFrameDescription(frame).c_str(), dest_url.c_str());
+  }
+}
+
+void TestWebViewDelegate::DidCancelClientRedirect(WebView* webview,
+                                                  WebFrame* frame) {
+  if (shell_->ShouldDumpFrameLoadCallbacks()) {
+    printf("%S - didCancelClientRedirectForFrame\n",
+           GetFrameDescription(frame).c_str());
+  }
+}
+
+void TestWebViewDelegate::AddMessageToConsole(WebView* webview,
+                                              const std::wstring& message,
+                                              unsigned int line_no,
+                                              const std::wstring& source_id) {
+  if (shell_->interactive()) {
+    logging::LogMessage("CONSOLE", 0).stream() << "\"" 
+                                               << message.c_str() 
+                                               << ",\" source: " 
+                                               << source_id.c_str() 
+                                               << "(" 
+                                               << line_no 
+                                               << ")";
+  } else {
+    // This matches win DumpRenderTree's UIDelegate.cpp.
+    std::wstring new_message = message;
+    if (!message.empty()) {
+      new_message = message;
+      size_t file_protocol = new_message.find(L"file://");
+      if (file_protocol != std::wstring::npos) {
+        new_message = new_message.substr(0, file_protocol) + new_message;
+            // UrlSuitableForTestResult(new_message);
+      }
+    }
+
+    std::string utf8 = WideToUTF8(new_message);
+    printf("CONSOLE MESSAGE: line %d: %s\n", line_no, utf8.c_str());
+  }
+}
+
+void TestWebViewDelegate::RunJavaScriptAlert(WebView* webview,
+                                             const std::wstring& message) {
+  if (shell_->interactive()) {
+    NOTIMPLEMENTED();
+  } else {
+    std::string utf8 = WideToUTF8(message);
+    printf("ALERT: %s\n", utf8.c_str());
+  }
+}
+
+bool TestWebViewDelegate::RunJavaScriptConfirm(WebView* webview,
+                                               const std::wstring& message) {
+  if (!shell_->interactive()) {
+    // When running tests, write to stdout.
+    std::string utf8 = WideToUTF8(message);
+    printf("CONFIRM: %s\n", utf8.c_str());
+    return true;
+  }
+  return false;
+}
+
+bool TestWebViewDelegate::RunJavaScriptPrompt(WebView* webview,
+    const std::wstring& message, const std::wstring& default_value,
+    std::wstring* result) {
+  if (!shell_->interactive()) {
+    // When running tests, write to stdout.
+    std::string utf8_message = WideToUTF8(message);
+    std::string utf8_default_value = WideToUTF8(default_value);
+    printf("PROMPT: %s, default text: %s\n", utf8_message.c_str(),
+           utf8_default_value.c_str());
+    return true;
+  }
+  return false;
+}
+
+void TestWebViewDelegate::StartDragging(WebView* webview,
+                                        const WebDropData& drop_data) {
+}
+
+void TestWebViewDelegate::ShowContextMenu(WebView* webview,
+                                          ContextNode::Type type,
+                                          int x,
+                                          int y,
+                                          const GURL& link_url,
+                                          const GURL& image_url,
+                                          const GURL& page_url,
+                                          const GURL& frame_url,
+                                          const std::wstring& selection_text,
+                                          const std::wstring& misspelled_word,
+                                          int edit_flags,
+                                          const std::string& security_info) {
+  CapturedContextMenuEvent context(type, x, y);
+  captured_context_menu_events_.push_back(context);
+}
+
+// The output from these methods in non-interactive mode should match that
+// expected by the layout tests.  See EditingDelegate.m in DumpRenderTree.
+bool TestWebViewDelegate::ShouldBeginEditing(WebView* webview, 
+                                             std::wstring range) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8 = WideToUTF8(range);
+    printf("EDITING DELEGATE: shouldBeginEditingInDOMRange:%s\n", 
+           utf8.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldEndEditing(WebView* webview, 
+                                           std::wstring range) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8 = WideToUTF8(range);
+    printf("EDITING DELEGATE: shouldEndEditingInDOMRange:%s\n", 
+           utf8.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldInsertNode(WebView* webview, 
+                                           std::wstring node, 
+                                           std::wstring range,
+                                           std::wstring action) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8_node = WideToUTF8(node);
+    std::string utf8_range = WideToUTF8(range);
+    std::string utf8_action = WideToUTF8(action);
+    printf("EDITING DELEGATE: shouldInsertNode:%s "
+               "replacingDOMRange:%s givenAction:%s\n", 
+           utf8_node.c_str(), utf8_range.c_str(), utf8_action.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldInsertText(WebView* webview, 
+                                           std::wstring text, 
+                                           std::wstring range,
+                                           std::wstring action) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8_text = WideToUTF8(text);
+    std::string utf8_range = WideToUTF8(range);
+    std::string utf8_action = WideToUTF8(action);
+    printf("EDITING DELEGATE: shouldInsertText:%s "
+               "replacingDOMRange:%s givenAction:%s\n", 
+           utf8_text.c_str(), utf8_range.c_str(), utf8_action.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldChangeSelectedRange(WebView* webview, 
+                                                    std::wstring fromRange, 
+                                                    std::wstring toRange, 
+                                                    std::wstring affinity, 
+                                                    bool stillSelecting) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8_from = WideToUTF8(fromRange);
+    std::string utf8_to = WideToUTF8(toRange);
+    std::string utf8_affinity = WideToUTF8(affinity);
+    printf("EDITING DELEGATE: shouldChangeSelectedDOMRange:%s "
+               "toDOMRange:%s affinity:%s stillSelecting:%s\n", 
+           utf8_from.c_str(), 
+           utf8_to.c_str(), 
+           utf8_affinity.c_str(),
+           (stillSelecting ? "TRUE" : "FALSE"));
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldDeleteRange(WebView* webview, 
+                                            std::wstring range) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8 = WideToUTF8(range);
+    printf("EDITING DELEGATE: shouldDeleteDOMRange:%s\n", utf8.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::ShouldApplyStyle(WebView* webview, 
+                                           std::wstring style,
+                                           std::wstring range) {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    std::string utf8_style = WideToUTF8(style);
+    std::string utf8_range = WideToUTF8(range);
+    printf("EDITING DELEGATE: shouldApplyStyle:%s toElementsInDOMRange:%s\n", 
+           utf8_style.c_str(), utf8_range.c_str());
+  }
+  return shell_->AcceptsEditing();
+}
+
+bool TestWebViewDelegate::SmartInsertDeleteEnabled() {
+  return true;
+}
+
+void TestWebViewDelegate::DidBeginEditing() { 
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    printf("EDITING DELEGATE: "
+           "webViewDidBeginEditing:WebViewDidBeginEditingNotification\n");
+  }
+}
+
+void TestWebViewDelegate::DidChangeSelection() {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    printf("EDITING DELEGATE: "
+    "webViewDidChangeSelection:WebViewDidChangeSelectionNotification\n");
+  }
+}
+
+void TestWebViewDelegate::DidChangeContents() {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    printf("EDITING DELEGATE: "
+           "webViewDidChange:WebViewDidChangeNotification\n");
+  }
+}
+
+void TestWebViewDelegate::DidEndEditing() {
+  if (shell_->ShouldDumpEditingCallbacks()) {
+    printf("EDITING DELEGATE: "
+           "webViewDidEndEditing:WebViewDidEndEditingNotification\n");
+  }
+}
+
+WebHistoryItem* TestWebViewDelegate::GetHistoryEntryAtOffset(int offset) {
+  TestNavigationEntry* entry = static_cast<TestNavigationEntry*>(
+      shell_->navigation_controller()->GetEntryAtOffset(offset));
+  if (!entry)
+    return NULL;
+
+  return entry->GetHistoryItem();
+}
+
+void TestWebViewDelegate::GoToEntryAtOffsetAsync(int offset) {
+  shell_->navigation_controller()->GoToOffset(offset);
+}
+
+int TestWebViewDelegate::GetHistoryBackListCount() {
+  int current_index =
+      shell_->navigation_controller()->GetLastCommittedEntryIndex();
+  return current_index;
+}
+
+int TestWebViewDelegate::GetHistoryForwardListCount() {
+  int current_index =
+      shell_->navigation_controller()->GetLastCommittedEntryIndex();
+  return shell_->navigation_controller()->GetEntryCount() - current_index - 1;
+}
+
+void TestWebViewDelegate::SetUserStyleSheetEnabled(bool is_enabled) {
+  WebPreferences* prefs = shell_->GetWebPreferences();
+  prefs->user_style_sheet_enabled = is_enabled;
+  shell_->webView()->SetPreferences(*prefs);
+}
+
+void TestWebViewDelegate::SetUserStyleSheetLocation(const GURL& location) {
+  WebPreferences* prefs = shell_->GetWebPreferences();
+  prefs->user_style_sheet_location = location;
+  shell_->webView()->SetPreferences(*prefs);
+}
+
+// WebWidgetDelegate ---------------------------------------------------------
+
+gfx::ViewHandle TestWebViewDelegate::GetContainingWindow(WebWidget* webwidget) {
+  if (WebWidgetHost* host = GetHostForWidget(webwidget))
+    return host->window_handle();
+
+  return NULL;
+}
+
+void TestWebViewDelegate::DidInvalidateRect(WebWidget* webwidget,
+                                            const gfx::Rect& rect) {
+  NOTIMPLEMENTED();
+}
+
+void TestWebViewDelegate::DidScrollRect(WebWidget* webwidget, int dx, int dy,
+                                        const gfx::Rect& clip_rect) {
+  if (WebWidgetHost* host = GetHostForWidget(webwidget))
+    host->DidScrollRect(dx, dy, clip_rect);
+}
+
+void TestWebViewDelegate::Show(WebWidget* webview,
+                               WindowOpenDisposition disposition) {
+}
+
+void TestWebViewDelegate::CloseWidgetSoon(WebWidget* webwidget) {
+  NOTIMPLEMENTED();
+}
+
+void TestWebViewDelegate::Focus(WebWidget* webwidget) {
+  if (WebWidgetHost* host = GetHostForWidget(webwidget))
+    shell_->SetFocus(host, true);
+}
+
+void TestWebViewDelegate::Blur(WebWidget* webwidget) {
+  if (WebWidgetHost* host = GetHostForWidget(webwidget))
+    shell_->SetFocus(host, false);
+}
+
+void TestWebViewDelegate::SetCursor(WebWidget* webwidget, 
+                                    const WebCursor& cursor) {
+  //TODO: Mac cursor handling
+}
+
+void TestWebViewDelegate::GetWindowRect(WebWidget* webwidget,
+                                        gfx::Rect* out_rect) {
+  DCHECK(out_rect);
+  //if (WebWidgetHost* host = GetHostForWidget(webwidget)) {
+    NOTIMPLEMENTED();
+  //}
+}
+
+void TestWebViewDelegate::SetWindowRect(WebWidget* webwidget,
+                                        const gfx::Rect& rect) {
+  // TODO: Mac window movement
+  if (webwidget == shell_->webView()) {
+    // ignored
+  } else if (webwidget == shell_->popup()) {
+    // MoveWindow(shell_->popupWnd(),
+    //            rect.x(), rect.y(), rect.width(), rect.height(), FALSE);
+  }
+}
+
+void TestWebViewDelegate::GetRootWindowRect(WebWidget* webwidget,
+                                            gfx::Rect* out_rect) {
+  //if (WebWidgetHost* host = GetHostForWidget(webwidget)) {
+    NOTIMPLEMENTED();
+  //}
+}
+
+void TestWebViewDelegate::DidMove(WebWidget* webwidget,
+                                  const WebPluginGeometry& move) {
+  // TODO: uncomment when Mac plugins are working
+  // WebPluginDelegateImpl::MoveWindow(
+  //     move.window, move.window_rect, move.clip_rect, move.visible); */
+}
+
+void TestWebViewDelegate::RegisterDragDrop() {
+  // TODO: uncomment when Mac drag and drop is working
+  // DCHECK(!drop_delegate_);
+  // drop_delegate_ = new TestDropDelegate(shell_->webViewWnd(),
+  //                                        shell_->webView());
+}
+
+void TestWebViewDelegate::RunModal(WebWidget* webwidget) {
+  // TODO(pinkerton): implement me
+}
+
+bool TestWebViewDelegate::IsHidden() {
+  return false;
+}
+
+// Private methods -----------------------------------------------------------
+
+void TestWebViewDelegate::UpdateAddressBar(WebView* webView) {
+  WebFrame* mainFrame = webView->GetMainFrame();
+
+  WebDataSource* dataSource = mainFrame->GetDataSource();
+  if (!dataSource)
+    dataSource = mainFrame->GetProvisionalDataSource();
+  if (!dataSource)
+    return;
+
+  std::string frameURL = dataSource->GetRequest().GetMainDocumentURL().spec();
+  NOTIMPLEMENTED();
+}
+
+void TestWebViewDelegate::LocationChangeDone(WebDataSource* data_source) {
+  if (data_source->GetWebFrame() == top_loading_frame_) {
+    top_loading_frame_ = NULL;
+    NOTIMPLEMENTED();
+
+    if (!shell_->interactive())
+      shell_->layout_test_controller()->LocationChangeDone();
+  }
+}
+
+WebWidgetHost* TestWebViewDelegate::GetHostForWidget(WebWidget* webwidget) {
+  if (webwidget == shell_->webView())
+    return shell_->webViewHost();
+  if (webwidget == shell_->popup())
+    return shell_->popupHost();
+  return NULL;
+}
+
+void TestWebViewDelegate::UpdateForCommittedLoad(WebFrame* frame,
+                                                 bool is_new_navigation) {
+  WebView* webview = shell_->webView();
+
+  // Code duplicated from RenderView::DidCommitLoadForFrame.
+  const WebRequest& request =
+      webview->GetMainFrame()->GetDataSource()->GetRequest();
+  TestShellExtraRequestData* extra_data =
+      static_cast<TestShellExtraRequestData*>(request.GetExtraData());
+
+  if (is_new_navigation) {
+    // New navigation.
+    UpdateSessionHistory(frame);
+    page_id_ = next_page_id_++;
+  } else if (extra_data && extra_data->pending_page_id != -1 &&
+             !extra_data->request_committed) {
+    // This is a successful session history navigation!
+    UpdateSessionHistory(frame);
+    page_id_ = extra_data->pending_page_id;
+  }
+
+  // Don't update session history multiple times.
+  if (extra_data)
+    extra_data->request_committed = true;
+
+  UpdateURL(frame);
+}
+
+void TestWebViewDelegate::UpdateURL(WebFrame* frame) {
+  WebDataSource* ds = frame->GetDataSource();
+  DCHECK(ds);
+
+  const WebRequest& request = ds->GetRequest();
+
+  scoped_ptr<TestNavigationEntry> entry(new TestNavigationEntry);
+
+  // Bug 654101: the referrer will be empty on https->http transitions. It
+  // would be nice if we could get the real referrer from somewhere.
+  entry->SetPageID(page_id_);
+  if (ds->HasUnreachableURL()) {
+    entry->SetURL(GURL(ds->GetUnreachableURL()));
+  } else {
+    entry->SetURL(GURL(request.GetURL()));
+  }
+
+  shell_->navigation_controller()->DidNavigateToEntry(entry.release());
+
+  last_page_id_updated_ = std::max(last_page_id_updated_, page_id_);
+}
+
+void TestWebViewDelegate::UpdateSessionHistory(WebFrame* frame) {
+  // If we have a valid page ID at this point, then it corresponds to the page
+  // we are navigating away from.  Otherwise, this is the first navigation, so
+  // there is no past session history to record.
+  if (page_id_ == -1)
+    return;
+
+  TestNavigationEntry* entry = static_cast<TestNavigationEntry*>(
+      shell_->navigation_controller()->GetEntryWithPageID(page_id_));
+  if (!entry)
+    return;
+
+  GURL url;
+  std::wstring title;
+  std::string state;
+  if (!shell_->webView()->GetMainFrame()->
+      GetPreviousState(&url, &title, &state))
+    return;
+
+  entry->SetURL(url);
+  entry->SetTitle(title);
+  entry->SetContentState(state);
+}
+
+std::wstring TestWebViewDelegate::GetFrameDescription(WebFrame* webframe) {
+  std::wstring name = webframe->GetName();
+
+  if (webframe == shell_->webView()->GetMainFrame()) {
+    if (name.length())
+      return L"main frame \"" + name + L"\"";
+    else
+      return L"main frame";
+  } else {
+    if (name.length())
+      return L"frame \"" + name + L"\"";
+    else
+      return L"frame (anonymous)";
+  }
+}
diff --git a/webkit/tools/test_shell/gtk/webwidget_host.cc b/webkit/tools/test_shell/gtk/webwidget_host.cc
index 46e3a83..847a0a7 100644
--- a/webkit/tools/test_shell/gtk/webwidget_host.cc
+++ b/webkit/tools/test_shell/gtk/webwidget_host.cc
@@ -92,6 +92,10 @@ WebWidgetHost* WebWidgetHost::Create(gfx::WindowHandle box,
   return host;
 }
 
+void WebWidgetHost::DidScrollRect(int dx, int dy, const gfx::Rect& clip_rect) {
+  NOTIMPLEMENTED();
+}
+
 WebWidgetHost* FromWindow(gfx::WindowHandle view) {
   const gpointer p = g_object_get_data(G_OBJECT(view), "webwidgethost");
   return (WebWidgetHost* ) p;
diff --git a/webkit/tools/test_shell/test_shell_main_gtk.cc b/webkit/tools/test_shell/test_shell_main_gtk.cc
index afee3e4..48cf47a 100644
--- a/webkit/tools/test_shell/test_shell_main_gtk.cc
+++ b/webkit/tools/test_shell/test_shell_main_gtk.cc
@@ -10,6 +10,7 @@
 #include "base/icu_util.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "base/message_loop.h"
 #include "webkit/tools/test_shell/test_shell.h"
 #include "webkit/tools/test_shell/test_shell_switches.h"
 
@@ -53,13 +54,14 @@ int main(int argc, char* argv[]) {
     uri = *iter;
   }
 
+  MessageLoopForUI main_message_loop;
+
   TestShell* shell;
   if (TestShell::CreateNewWindow(uri, &shell)) {
     // TODO(port): the rest of this.  :)
   }
 
-  // TODO(port): use MessageLoop instead.
-  gtk_main();
+  main_message_loop.Run();
 
   return 0;
 }