test_webview_delegate.cc was forked for the Mac test shell, and then

webkit/tools/test_shell/gtk/test_webview_delegate.cc

 // 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 <gtk/gtk.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) {
+  NOTIMPLEMENTED();
   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());
-  }
-  gtk_window_set_title(GTK_WINDOW(shell_->mainWnd()), WideToUTF8(title).c_str()); 
-}
-
-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::ShowJavaScriptAlert(const std::wstring& message) {
+  NOTIMPLEMENTED();
 }
 
 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();
-}
-
-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) {
-  WebWidgetHost* host = GetHostForWidget(webwidget);
-  if (host)
-    host->DidInvalidateRect(rect);
-}
-
-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);
+  NOTIMPLEMENTED();
 }
 
 void TestWebViewDelegate::Show(WebWidget* webview,
                                WindowOpenDisposition disposition) {
+  NOTIMPLEMENTED();
 }
 
 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
+  // TODO(port): GTK cursor handling.

[tony, 2008/11/09 18:07:50]

Nit: NOTIMPLEMENTED()?

 }
 
 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
+  // TODO(port): window movement
   if (webwidget == shell_->webView()) {
     // ignored
   } else if (webwidget == shell_->popup()) {
     // MoveWindow(shell_->popupWnd(),

[tony, 2008/11/09 18:07:50]

NOTIMPLEMENTED?

     //            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;
+  NOTIMPLEMENTED();
 }
 
 // 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();
-  LOG(INFO) << "  -- Address bar " << frameURL;
-
-  gtk_entry_set_text(GTK_ENTRY(shell_->editWnd()), frameURL.c_str());
+void TestWebViewDelegate::SetPageTitle(const std::wstring& title) {
+  gtk_window_set_title(GTK_WINDOW(shell_->mainWnd()),
+                       ("Test Shell - " + WideToUTF8(title)).c_str());
 }
 
-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();
-  }
+void TestWebViewDelegate::SetAddressBarURL(const GURL& url) {
+  gtk_entry_set_text(GTK_ENTRY(shell_->editWnd()), url.spec().c_str());
 }
-
-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)";
-  }
-}