Switch to WebFrame from the WebKit API....

webkit/tools/test_shell/test_webview_delegate.cc

 // Copyright (c) 2006-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 contains the implementation of TestWebViewDelegate, which serves
 // as the WebViewDelegate for the TestShellWebHost.  The host is expected to
 // have initialized a MessageLoop before these methods are called.
 
 #include "config.h"
 
 #include "webkit/tools/test_shell/test_webview_delegate.h"
 
 #include "base/file_util.h"
 #include "base/gfx/point.h"
 #include "base/gfx/native_widget_types.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/net_errors.h"
 #include "webkit/api/public/WebData.h"
 #include "webkit/api/public/WebDataSource.h"
 #include "webkit/api/public/WebDragData.h"
 #include "webkit/api/public/WebHistoryItem.h"
+#include "webkit/api/public/WebFrame.h"
 #include "webkit/api/public/WebKit.h"
 #include "webkit/api/public/WebScreenInfo.h"
 #include "webkit/api/public/WebString.h"
 #include "webkit/api/public/WebURL.h"
 #include "webkit/api/public/WebURLError.h"
 #include "webkit/api/public/WebURLRequest.h"
 #include "webkit/api/public/WebURLResponse.h"
 #include "webkit/glue/glue_serialize.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/glue/media/media_resource_loader_bridge_factory.h"
 #include "webkit/glue/media/simple_data_source.h"
 #include "webkit/glue/webappcachecontext.h"
 #include "webkit/glue/webdropdata.h"
-#include "webkit/glue/webframe.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webview.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 #include "webkit/glue/webmediaplayer_impl.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"
 #include "webkit/tools/test_shell/test_webworker_helper.h"
 
 #if defined(OS_WIN)
 // TODO(port): make these files work everywhere.
 #include "webkit/tools/test_shell/drag_delegate.h"
 #include "webkit/tools/test_shell/drop_delegate.h"
 #endif
 
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDragData;
+using WebKit::WebFrame;
 using WebKit::WebHistoryItem;
 using WebKit::WebNavigationType;
 using WebKit::WebNavigationPolicy;
 using WebKit::WebRect;
 using WebKit::WebScreenInfo;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
@@ skipping 164 matching lines @@
 
 WebNavigationPolicy TestWebViewDelegate::PolicyForNavigationAction(
     WebView* webview,
     WebFrame* frame,
     const WebURLRequest& request,
     WebNavigationType type,
     WebNavigationPolicy default_policy,
     bool is_redirect) {
   WebNavigationPolicy result;
   if (policy_delegate_enabled_) {
-    std::wstring frame_name = frame->GetName();
     printf("Policy delegate: attempt to load %s with navigation type '%s'\n",
            GetURLDescription(request.url()).c_str(),
            WebNavigationTypeToString(type));
     if (policy_delegate_is_permissive_) {
       result = WebKit::WebNavigationPolicyCurrentTab;
     } else {
       result = WebKit::WebNavigationPolicyIgnore;
     }
     if (policy_delegate_should_notify_done_)
       shell_->layout_test_controller()->PolicyDelegateDone();
@@ skipping 110 matching lines @@
            GetFrameDescription(frame).c_str());
   }
 
   if (!top_loading_frame_) {
     top_loading_frame_ = frame;
   }
 
   if (shell_->layout_test_controller()->StopProvisionalFrameLoads()) {
     printf("%S - stopping load in didStartProvisionalLoadForFrame callback\n",
            GetFrameDescription(frame).c_str());
-    frame->StopLoading();
+    frame->stopLoading();
   }
   UpdateAddressBar(webview);
 }
 
 void TestWebViewDelegate::DidReceiveProvisionalLoadServerRedirect(
     WebView* webview,
     WebFrame* frame) {
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didReceiveServerRedirectForProvisionalLoadForFrame\n",
            GetFrameDescription(frame).c_str());
@@ skipping 16 matching lines @@
   // Don't display an error page if we're running layout tests, because
   // DumpRenderTree doesn't.
   if (shell_->layout_test_mode())
     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.reason == net::ERR_ABORTED)
     return;
 
-  const WebDataSource* failed_ds = frame->GetProvisionalDataSource();
+  const WebDataSource* failed_ds = frame->provisionalDataSource();
 
   TestShellExtraData* extra_data =
       static_cast<TestShellExtraData*>(failed_ds->extraData());
   bool replace = extra_data && extra_data->pending_page_id != -1;
 
   const std::string& error_text =
       StringPrintf("Error %d when loading url %s", error.reason,
       failed_ds->request().url().spec().data());
 
   // Make sure we never show errors in view source mode.
-  frame->SetInViewSourceMode(false);
+  frame->enableViewSourceMode(false);
 
-  frame->LoadHTMLString(
+  frame->loadHTMLString(
       error_text, GURL("testshell-error:"), error.unreachableURL, replace);
 }
 
 void TestWebViewDelegate::DidCommitLoadForFrame(WebView* webview,
                                                 WebFrame* frame,
                                                 bool is_new_navigation) {
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didCommitLoadForFrame\n",
            GetFrameDescription(frame).c_str());
   }
@@ skipping 11 matching lines @@
 
   if (shell_->ShouldDumpTitleChanges()) {
     printf("TITLE CHANGED: %S\n", title.c_str());
   }
 
   SetPageTitle(title);
 }
 
 void TestWebViewDelegate::DidFinishLoadForFrame(WebView* webview,
                                                 WebFrame* frame) {
-  TRACE_EVENT_END("frame.load", this, frame->GetURL().spec());
+  TRACE_EVENT_END("frame.load", this, frame->url().spec());
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didFinishLoadForFrame\n",
            GetFrameDescription(frame).c_str());
   }
 
   UpdateAddressBar(webview);
   LocationChangeDone(frame);
 }
 
 void TestWebViewDelegate::DidFailLoadWithError(WebView* webview,
                                                const WebURLError& error,
                                                WebFrame* frame) {
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didFailLoadWithError\n",
            GetFrameDescription(frame).c_str());
   }
 
   LocationChangeDone(frame);
 }
 
 void TestWebViewDelegate::DidFinishDocumentLoadForFrame(WebView* webview,
                                                         WebFrame* frame) {
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didFinishDocumentLoadForFrame\n",
            GetFrameDescription(frame).c_str());
   } else {
-    unsigned pending_unload_events = frame->PendingFrameUnloadEventCount();
+    unsigned pending_unload_events = frame->unloadListenerCount();
     if (pending_unload_events) {
       printf("%S - has %u onunload handler(s)\n",
           GetFrameDescription(frame).c_str(), pending_unload_events);
     }
   }
 }
 
 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) {
-  frame->GetDataSource()->setExtraData(pending_extra_data_.release());
+  frame->dataSource()->setExtraData(pending_extra_data_.release());
 
   if (shell_->ShouldDumpFrameLoadCallbacks()) {
     printf("%S - didChangeLocationWithinPageForFrame\n",
            GetFrameDescription(frame).c_str());
   }
 
   UpdateForCommittedLoad(frame, is_new_navigation);
 }
 
 void TestWebViewDelegate::DidReceiveIconForFrame(WebView* webview,
@@ skipping 365 matching lines @@
 void TestWebViewDelegate::WaitForPolicyDelegate() {
   policy_delegate_enabled_ = true;
   policy_delegate_should_notify_done_ = true;
 }
 
 // Private methods -----------------------------------------------------------
 
 void TestWebViewDelegate::UpdateAddressBar(WebView* webView) {
   WebFrame* mainFrame = webView->GetMainFrame();
 
-  WebDataSource* dataSource = mainFrame->GetDataSource();
+  WebDataSource* dataSource = mainFrame->dataSource();
   if (!dataSource)
-    dataSource = mainFrame->GetProvisionalDataSource();
+    dataSource = mainFrame->provisionalDataSource();
   if (!dataSource)
     return;
 
   // TODO(abarth): This is wrong!
   SetAddressBarURL(dataSource->request().firstPartyForCookies());
 }
 
 void TestWebViewDelegate::LocationChangeDone(WebFrame* frame) {
   if (frame == top_loading_frame_) {
     top_loading_frame_ = NULL;
 
     if (shell_->layout_test_mode())
       shell_->layout_test_controller()->LocationChangeDone();
   }
 }
 
 WebWidgetHost* TestWebViewDelegate::GetWidgetHost() {
   if (this == shell_->delegate())
     return shell_->webViewHost();
   if (this == shell_->popup_delegate())
     return shell_->popupHost();
   return NULL;
 }
 
 void TestWebViewDelegate::UpdateForCommittedLoad(WebFrame* frame,
                                                  bool is_new_navigation) {
   // Code duplicated from RenderView::DidCommitLoadForFrame.
   TestShellExtraData* extra_data = static_cast<TestShellExtraData*>(
-      frame->GetDataSource()->extraData());
+      frame->dataSource()->extraData());
 
   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();
+  WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
 
   // Type is unused.
   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(ds->unreachableURL());
   } else {
     entry->SetURL(request.url());
   }
 
-  const WebHistoryItem& history_item = frame->GetCurrentHistoryItem();
+  const WebHistoryItem& history_item = frame->currentHistoryItem();
   if (!history_item.isNull())
     entry->SetContentState(webkit_glue::HistoryItemToString(history_item));
 
   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;
 
   const WebHistoryItem& history_item =
-      shell_->webView()->GetMainFrame()->GetPreviousHistoryItem();
+      shell_->webView()->GetMainFrame()->previousHistoryItem();
   if (history_item.isNull())
     return;
 
   entry->SetContentState(webkit_glue::HistoryItemToString(history_item));
 }
 
 std::wstring TestWebViewDelegate::GetFrameDescription(WebFrame* webframe) {
-  std::wstring name = webframe->GetName();
+  std::wstring name = UTF16ToWideHack(webframe->name());
 
   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)";
   }
 }