Switch to WebFrame from the WebKit API....

chrome/renderer/render_view.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/renderer/render_view.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 40 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/renderer_resources.h"
 #include "net/base/data_url.h"
 #include "net/base/escape.h"
 #include "net/base/net_errors.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/image_operations.h"
 #include "webkit/api/public/WebDataSource.h"
 #include "webkit/api/public/WebDragData.h"
 #include "webkit/api/public/WebForm.h"
+#include "webkit/api/public/WebFrame.h"
 #include "webkit/api/public/WebHistoryItem.h"
 #include "webkit/api/public/WebNode.h"
 #include "webkit/api/public/WebPoint.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebScriptSource.h"
 #include "webkit/api/public/WebSize.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/api/public/WebVector.h"
 #include "webkit/default_plugin/default_plugin_shared.h"
 #include "webkit/glue/glue_serialize.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/dom_serializer.h"
 #include "webkit/glue/image_decoder.h"
 #include "webkit/glue/media/buffered_data_source.h"
 #include "webkit/glue/media/simple_data_source.h"
 #include "webkit/glue/password_form.h"
 #include "webkit/glue/plugins/plugin_list.h"
 #include "webkit/glue/searchable_form_data.h"
 #include "webkit/glue/webaccessibilitymanager_impl.h"
 #include "webkit/glue/webdevtoolsagent_delegate.h"
 #include "webkit/glue/webdropdata.h"
-#include "webkit/glue/webframe.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webmediaplayer_impl.h"
 #include "webkit/glue/webpreferences.h"
 #include "webkit/glue/webplugin_delegate.h"
-#include "webkit/glue/webtextinput.h"
 #include "webkit/glue/webview.h"
 
 #if defined(OS_WIN)
 // TODO(port): these files are currently Windows only because they concern:
 //   * theming
 #include "base/gfx/native_theme.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::AutofillForm;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::SearchableFormData;
 using WebKit::WebConsoleMessage;
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebDragData;
 using WebKit::WebForm;
+using WebKit::WebFrame;
 using WebKit::WebHistoryItem;
 using WebKit::WebNavigationPolicy;
 using WebKit::WebNavigationType;
 using WebKit::WebPopupMenuInfo;
 using WebKit::WebRect;
 using WebKit::WebScriptSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebTextDirection;
 using WebKit::WebURL;
@@ skipping 209 matching lines @@
   if (command_line.HasSwitch(switches::kDomAutomationController))
     enabled_bindings_ |= BindingsPolicy::DOM_AUTOMATION;
 
   audio_message_filter_ = new AudioMessageFilter(routing_id_);
   render_thread_->AddFilter(audio_message_filter_);
 }
 
 void RenderView::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->GetMainFrame() : NULL;
   child_process_logging::ScopedActiveURLSetter url_setter(
-      main_frame ? main_frame->GetURL() : GURL());
+      main_frame ? main_frame->url() : WebURL());
 
   // If this is developer tools renderer intercept tools messages first.
   if (devtools_client_.get() && devtools_client_->OnMessageReceived(message))
     return;
   if (devtools_agent_.get() && devtools_agent_->OnMessageReceived(message))
     return;
 
   IPC_BEGIN_MESSAGE_MAP(RenderView, message)
     IPC_MESSAGE_HANDLER(ViewMsg_CaptureThumbnail, SendThumbnail)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintPages, OnPrintPages)
@@ skipping 83 matching lines @@
     IPC_MESSAGE_UNHANDLED(RenderWidget::OnMessageReceived(message))
   IPC_END_MESSAGE_MAP()
 }
 
 void RenderView::SendThumbnail() {
   WebFrame* main_frame = webview()->GetMainFrame();
   if (!main_frame)
     return;
 
   // get the URL for this page
-  GURL url(main_frame->GetURL());
+  GURL url(main_frame->url());
   if (url.is_empty())
     return;
 
   if (size_.IsEmpty())
     return;  // Don't create an empty thumbnail!
 
   ThumbnailScore score;
   SkBitmap thumbnail;
   if (!CaptureThumbnail(webview(), kThumbnailWidth, kThumbnailHeight,
                         &thumbnail, &score))
     return;
 
   // send the thumbnail message to the browser process
   Send(new ViewHostMsg_Thumbnail(routing_id_, url, score, thumbnail));
 }
 
 void RenderView::OnPrintPages() {
   DCHECK(webview());
   if (webview()) {
     // If the user has selected text in the currently focused frame we print
     // only that frame (this makes print selection work for multiple frames).
-    if (webview()->GetFocusedFrame()->HasSelection())
+    if (webview()->GetFocusedFrame()->hasSelection())
       Print(webview()->GetFocusedFrame(), false);
     else
       Print(webview()->GetMainFrame(), false);
   }
 }
 
 void RenderView::OnPrintingDone(int document_cookie, bool success) {
   // Ignoring document cookie here since only one print job can be outstanding
   // per renderer and document_cookie is 0 when printing is successful.
   DCHECK(print_helper_.get());
   if (print_helper_.get() != NULL) {
     print_helper_->DidFinishPrinting(success);
   }
 }
 
 void RenderView::CapturePageInfo(int load_id, bool preliminary_capture) {
   if (load_id != page_id_)
     return;  // this capture call is no longer relevant due to navigation
   if (load_id == last_indexed_page_id_)
     return;  // we already indexed this page
 
   if (!webview())
     return;
 
   WebFrame* main_frame = webview()->GetMainFrame();
   if (!main_frame)
     return;
 
   // Don't index/capture pages that are in view source mode.
-  if (main_frame->GetInViewSourceMode())
+  if (main_frame->isViewSourceModeEnabled())
     return;
 
   // Don't index/capture pages that failed to load.  This only checks the top
   // level frame so the thumbnail may contain a frame that failed to load.
-  WebDataSource* ds = main_frame->GetDataSource();
+  WebDataSource* ds = main_frame->dataSource();
   if (ds && ds->hasUnreachableURL())
     return;
 
   if (!preliminary_capture)
     last_indexed_page_id_ = load_id;
 
   // get the URL for this page
-  GURL url(main_frame->GetURL());
+  GURL url(main_frame->url());
   if (url.is_empty())
     return;
 
   // full text
   std::wstring contents;
   CaptureText(main_frame, &contents);
   if (contents.size()) {
     // Send the text to the browser for indexing.
     Send(new ViewHostMsg_PageContents(url, load_id, contents));
   }
@@ skipping 12 matching lines @@
   contents->clear();
   if (!frame)
     return;
 
   // Don't index any https pages. People generally don't want their bank
   // accounts, etc. indexed on their computer, especially since some of these
   // things are not marked cachable.
   // TODO(brettw) we may want to consider more elaborate heuristics such as
   // the cachability of the page. We may also want to consider subframes (this
   // test will still index subframes if the subframe is SSL).
-  if (frame->GetURL().SchemeIsSecure())
+  if (GURL(frame->url()).SchemeIsSecure())
     return;
 
 #ifdef TIME_TEXT_RETRIEVAL
   double begin = time_util::GetHighResolutionTimeNow();
 #endif
 
   // get the contents of the frame
-  frame->GetContentAsPlainText(kMaxIndexChars, contents);
+  *contents = UTF16ToWideHack(frame->contentAsText(kMaxIndexChars));
 
 #ifdef TIME_TEXT_RETRIEVAL
   double end = time_util::GetHighResolutionTimeNow();
   char buf[128];
   sprintf_s(buf, "%d chars retrieved for indexing in %gms\n",
             contents.size(), (end - begin)*1000);
   OutputDebugStringA(buf);
 #endif
 
   // When the contents are clipped to the maximum, we don't want to have a
@@ skipping 53 matching lines @@
       S16CPU x_offset = (src_bmp.width() - new_width) / 2;
       src_rect.set(x_offset, 0, new_width + x_offset, src_bmp.height());
       score->good_clipping = false;
     } else {
       src_rect.set(0, 0, src_bmp.width(),
                    static_cast<S16CPU>(src_bmp.width() / dest_aspect));
       score->good_clipping = true;
     }
   }
 
-  score->at_top = (view->GetMainFrame()->ScrollOffset().height == 0);
+  score->at_top = (view->GetMainFrame()->scrollOffset().height == 0);
 
   SkBitmap subset;
   device.accessBitmap(false).extractSubset(&subset, src_rect);
 
   // Resample the subset that we want to get it the right size.
   *thumbnail = skia::ImageOperations::Resize(
       subset, skia::ImageOperations::RESIZE_LANCZOS3, w, h);
 
   score->boring_score = CalculateBoringScore(thumbnail);
 
@@ skipping 22 matching lines @@
   if (devtools_agent_.get())
     devtools_agent_->OnNavigate();
 
   child_process_logging::ScopedActiveURLSetter url_setter(params.url);
 
   AboutHandler::MaybeHandle(params.url);
 
   bool is_reload = params.reload;
 
   WebFrame* main_frame = webview()->GetMainFrame();
-  if (is_reload && main_frame->GetCurrentHistoryItem().isNull()) {
+  if (is_reload && main_frame->currentHistoryItem().isNull()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.  Our workaround here is a bit of
     // a hack since it means that reload after a crashed tab does not cause an
     // end-to-end cache validation.
     is_reload = false;
   }
 
   // A navigation resulting from loading a javascript URL should not be treated
   // as a browser initiated event.  Instead, we want it to look as if the page
   // initiated any load resulting from JS execution.
   if (!params.url.SchemeIs(chrome::kJavaScriptScheme)) {
     pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
         params.page_id, params.transition, params.request_time));
   }
 
   // If we are reloading, then WebKit will use the history state of the current
   // page, so we should just ignore any given history state.  Otherwise, if we
   // have history state, then we need to navigate to it, which corresponds to a
   // back/forward navigation event.
   if (is_reload) {
-    main_frame->Reload();
+    main_frame->reload();
   } else if (!params.state.empty()) {
     // We must know the page ID of the page we are navigating back to.
     DCHECK_NE(params.page_id, -1);
-    main_frame->LoadHistoryItem(
+    main_frame->loadHistoryItem(
         webkit_glue::HistoryItemFromString(params.state));
   } else {
     // Navigate to the given URL.
     WebURLRequest request(params.url);
 
     // A session history navigation should have been accompanied by state.
     DCHECK_EQ(params.page_id, -1);
 
-    if (main_frame->GetInViewSourceMode())
+    if (main_frame->isViewSourceModeEnabled())
       request.setCachePolicy(WebURLRequest::ReturnCacheDataElseLoad);
 
     if (params.referrer.is_valid()) {
       request.setHTTPHeaderField(WebString::fromUTF8("Referer"),
                                  WebString::fromUTF8(params.referrer.spec()));
     }
 
-    main_frame->LoadRequest(request);
+    main_frame->loadRequest(request);
   }
 
   // In case LoadRequest failed before DidCreateDataSource was called.
   pending_navigation_state_.reset();
 }
 
 // Stop loading the current page
 void RenderView::OnStop() {
   if (webview())
     webview()->StopLoading();
 }
 
 void RenderView::OnLoadAlternateHTMLText(const std::string& html,
                                          bool new_navigation,
                                          const GURL& display_url,
                                          const std::string& security_info) {
   if (!webview())
     return;
 
   pending_navigation_state_.reset(NavigationState::CreateBrowserInitiated(
       new_navigation ? -1 : page_id_, PageTransition::LINK, Time::Now()));
   pending_navigation_state_->set_security_info(security_info);
 
-  webview()->GetMainFrame()->LoadHTMLString(html,
+  webview()->GetMainFrame()->loadHTMLString(html,
                                             GURL(kUnreachableWebDataURL),
                                             display_url,
                                             !new_navigation);
 
   pending_navigation_state_.reset();
 }
 
 void RenderView::OnCopyImageAt(int x, int y) {
   webview()->CopyImageAt(x, y);
 }
 
 void RenderView::OnExecuteEditCommand(const std::string& name,
     const std::string& value) {
   if (!webview() || !webview()->GetFocusedFrame())
     return;
 
-  webview()->GetFocusedFrame()->ExecuteEditCommandByName(name, value);
+  webview()->GetFocusedFrame()->executeCommand(
+      WebString::fromUTF8(name), WebString::fromUTF8(value));
 }
 
 void RenderView::OnSetupDevToolsClient() {
   DCHECK(!devtools_client_.get());
   devtools_client_.reset(new DevToolsClient(this));
 }
 
 void RenderView::OnStopFinding(bool clear_selection) {
   WebView* view = webview();
   if (!view)
     return;
 
   if (clear_selection)
-    view->GetFocusedFrame()->ClearSelection();
+    view->GetFocusedFrame()->clearSelection();
 
   WebFrame* frame = view->GetMainFrame();
   while (frame) {
-    frame->StopFinding(clear_selection);
+    frame->stopFinding(clear_selection);
     frame = view->GetNextFrameAfter(frame, false);
   }
 }
 
 void RenderView::OnFindReplyAck() {
   // Check if there is any queued up request waiting to be sent.
   if (queued_find_reply_message_.get()) {
     // Send the search result over to the browser process.
     Send(queued_find_reply_message_.get());
     queued_find_reply_message_.release();
   }
 }
 
 void RenderView::OnUpdateTargetURLAck() {
   // Check if there is a targeturl waiting to be sent.
   if (target_url_status_ == TARGET_PENDING) {
     Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_,
                                          pending_target_url_));
   }
 
   target_url_status_ = TARGET_NONE;
 }
 
 void RenderView::OnUndo() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Undo();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Undo"));
+  UserMetricsRecordAction(L"Undo");
 }
 
 void RenderView::OnRedo() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Redo();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Redo"));
+  UserMetricsRecordAction(L"Redo");
 }
 
 void RenderView::OnCut() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Cut();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Cut"));
+  UserMetricsRecordAction(L"Cut");
 }
 
 void RenderView::OnCopy() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Copy();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Copy"));
+  UserMetricsRecordAction(L"Copy");
 }
 
 void RenderView::OnPaste() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Paste();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Paste"));
+  UserMetricsRecordAction(L"Paste");
 }
 
 void RenderView::OnReplace(const std::wstring& text) {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Replace(text);
+  webview()->GetFocusedFrame()->replaceSelection(WideToUTF16Hack(text));
 }
 
 void RenderView::OnToggleSpellCheck() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->ToggleSpellCheck();
+  WebFrame* frame = webview()->GetFocusedFrame();
+  frame->enableContinuousSpellChecking(
+      !frame->isContinuousSpellCheckingEnabled());
 }
 
 void RenderView::OnDelete() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->Delete();
+  webview()->GetFocusedFrame()->executeCommand(WebString::fromUTF8("Delete"));
+  UserMetricsRecordAction(L"DeleteSelection");
 }
 
 void RenderView::OnSelectAll() {
   if (!webview())
     return;
 
-  webview()->GetFocusedFrame()->SelectAll();
+  webview()->GetFocusedFrame()->selectAll();
 }
 
 void RenderView::OnSetInitialFocus(bool reverse) {
   if (!webview())
     return;
   webview()->SetInitialFocus(reverse);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Tell the embedding application that the URL of the active page has changed
 void RenderView::UpdateURL(WebFrame* frame) {
-  WebDataSource* ds = frame->GetDataSource();
+  WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
   const WebURLRequest& request = ds->request();
   const WebURLRequest& original_request = ds->originalRequest();
   const WebURLResponse& response = ds->response();
 
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
 
   ViewHostMsg_FrameNavigate_Params params;
@@ skipping 31 matching lines @@
   }
 
   const PasswordForm* password_form_data =
       navigation_state->password_form_data();
   if (password_form_data)
     params.password_form = *password_form_data;
 
   params.gesture = navigation_gesture_;
   navigation_gesture_ = NavigationGestureUnknown;
 
-  if (!frame->GetParent()) {
+  if (!frame->parent()) {
     // Top-level navigation.
 
     // Update contents MIME type for main frame.
     params.contents_mime_type = UTF16ToUTF8(ds->response().mimeType());
 
     params.transition = navigation_state->transition_type();
     if (!PageTransition::IsMainFrame(params.transition)) {
       // If the main frame does a load, it should not be reported as a subframe
       // navigation.  This can occur in the following case:
       // 1. You're on a site with frames.
@@ skipping 87 matching lines @@
 // before we navigate to a new page. This must be called *before* the page ID
 // has been updated so we know what it was.
 void RenderView::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;
 
   const WebHistoryItem& item =
-      webview()->GetMainFrame()->GetPreviousHistoryItem();
+      webview()->GetMainFrame()->previousHistoryItem();
   if (item.isNull())
     return;
 
   Send(new ViewHostMsg_UpdateState(
       routing_id_, page_id_, webkit_glue::HistoryItemToString(item)));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebViewDelegate
 
@@ skipping 21 matching lines @@
     return;
   }
 
   is_loading_ = false;
 
   // NOTE: For now we're doing the safest thing, and sending out notification
   // when done loading. This currently isn't an issue as the favicon is only
   // displayed when done loading. Ideally we would send notification when
   // finished parsing the head, but webkit doesn't support that yet.
   // The feed discovery code would also benefit from access to the head.
-  GURL favicon_url(webview->GetMainFrame()->GetFavIconURL());
+  GURL favicon_url(webview->GetMainFrame()->favIconURL());
   if (!favicon_url.is_empty())
     Send(new ViewHostMsg_UpdateFavIconURL(routing_id_, page_id_, favicon_url));
 
-  AddGURLSearchProvider(webview->GetMainFrame()->GetOSDDURL(),
+  AddGURLSearchProvider(webview->GetMainFrame()->openSearchDescriptionURL(),
                         true);  // autodetected
 
   Send(new ViewHostMsg_DidStopLoading(routing_id_));
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       method_factory_.NewRunnableMethod(&RenderView::CapturePageInfo, page_id_,
                                         false),
       kDelayForCaptureMs);
 
   // The page is loaded. Try to process the file we need to upload if any.
@@ skipping 10 matching lines @@
   if (pending_navigation_state_.get()) {
     ds->setExtraData(pending_navigation_state_.release());
   } else {
     ds->setExtraData(NavigationState::CreateContentInitiated());
   }
 }
 
 void RenderView::DidPaint() {
   WebFrame* main_frame = webview()->GetMainFrame();
 
-  if (main_frame->GetProvisionalDataSource()) {
+  if (main_frame->provisionalDataSource()) {
     // If we have a provisional frame we are between the start
     // and commit stages of loading...ignore this paint.
     return;
   }
 
-  WebDataSource* ds = main_frame->GetDataSource();
+  WebDataSource* ds = main_frame->dataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
 
   Time now = Time::Now();
   if (navigation_state->first_paint_time().is_null()) {
     navigation_state->set_first_paint_time(now);
   }
   if (navigation_state->first_paint_after_load_time().is_null() &&
       !navigation_state->finish_load_time().is_null()) {
     navigation_state->set_first_paint_after_load_time(now);
   }
 }
 
 void RenderView::DidStartProvisionalLoadForFrame(
     WebView* webview,
     WebFrame* frame,
     NavigationGesture gesture) {
-  WebDataSource* ds = frame->GetProvisionalDataSource();
+  WebDataSource* ds = frame->provisionalDataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
 
   navigation_state->set_start_load_time(Time::Now());
 
   // Update the request time if WebKit has better knowledge of it.
   if (navigation_state->request_time().is_null()) {
     double event_time = ds->triggeringEventTime();
     if (event_time != 0.0)
       navigation_state->set_request_time(Time::FromDoubleT(event_time));
   }
 
-  bool is_top_most = !frame->GetParent();
+  bool is_top_most = !frame->parent();
   if (is_top_most) {
     navigation_gesture_ = gesture;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = GURL();
-  } else if (frame->GetParent()->IsLoading()) {
+  } else if (frame->parent()->isLoading()) {
     // Take note of AUTO_SUBFRAME loads here, so that we can know how to
     // load an error page.  See DidFailProvisionalLoadWithError.
     navigation_state->set_transition_type(PageTransition::AUTO_SUBFRAME);
   }
 
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, is_top_most, ds->request().url()));
 }
 
 bool RenderView::DidLoadResourceFromMemoryCache(WebView* webview,
                                                 const WebURLRequest& request,
                                                 const WebURLResponse& response,
                                                 WebFrame* frame) {
   // Let the browser know we loaded a resource from the memory cache.  This
   // message is needed to display the correct SSL indicators.
-  Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(routing_id_,
-      request.url(), frame->GetSecurityOrigin(),
-      frame->GetTop()->GetSecurityOrigin(),
+  Send(new ViewHostMsg_DidLoadResourceFromMemoryCache(
+      routing_id_,
+      request.url(),
+      frame->securityOrigin().utf8(),
+      frame->top()->securityOrigin().utf8(),
       response.securityInfo()));
 
   return false;
 }
 
 void RenderView::DidReceiveProvisionalLoadServerRedirect(WebView* webview,
                                                          WebFrame* frame) {
   if (frame == webview->GetMainFrame()) {
     // Received a redirect on the main frame.
     WebDataSource* data_source =
-        webview->GetMainFrame()->GetProvisionalDataSource();
+        webview->GetMainFrame()->provisionalDataSource();
     if (!data_source) {
       // Should only be invoked when we have a data source.
       NOTREACHED();
       return;
     }
     std::vector<GURL> redirects;
     GetRedirectChain(data_source, &redirects);
     if (redirects.size() >= 2) {
       Send(new ViewHostMsg_DidRedirectProvisionalLoad(
            routing_id_, page_id_, redirects[redirects.size() - 2],
            redirects[redirects.size() - 1]));
     }
   }
 }
 
 void RenderView::DidFailProvisionalLoadWithError(WebView* webview,
                                                  const WebURLError& error,
                                                  WebFrame* frame) {
   // Notify the browser that we failed a provisional load with an error.
   //
   // Note: It is important this notification occur before DidStopLoading so the
   //       SSL manager can react to the provisional load failure before being
   //       notified the load stopped.
   //
-  WebDataSource* ds = frame->GetProvisionalDataSource();
+  WebDataSource* ds = frame->provisionalDataSource();
   DCHECK(ds);
 
   const WebURLRequest& failed_request = ds->request();
 
   bool show_repost_interstitial =
       (error.reason == net::ERR_CACHE_MISS &&
        EqualsASCII(failed_request.httpMethod(), "POST"));
   Send(new ViewHostMsg_DidFailProvisionalLoadWithError(
-      routing_id_, !frame->GetParent(),
-      error.reason, error.unreachableURL,
+      routing_id_, !frame->parent(), error.reason, error.unreachableURL,
       show_repost_interstitial));
 
   // 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;
 
   // Make sure we never show errors in view source mode.
-  frame->SetInViewSourceMode(false);
+  frame->enableViewSourceMode(false);
 
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
 
   // If this is a failed back/forward/reload navigation, then we need to do a
   // 'replace' load.  This is necessary to avoid messing up session history.
   // Otherwise, we do a normal load, which simulates a 'go' navigation as far
   // as session history is concerned.
   //
   // AUTO_SUBFRAME loads should always be treated as loads that do not advance
   // the page id.
@@ skipping 42 matching lines @@
     }
     error_strings.SetString(L"textdirection",
       (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) ?
        L"rtl" : L"ltr");
 
     alt_html = GetAltHTMLForTemplate(error_strings, resource_id);
   } else {
     alt_html = html;
   }
 
-  frame->LoadHTMLString(alt_html,
+  frame->loadHTMLString(alt_html,
                         GURL(kUnreachableWebDataURL),
                         failed_url,
                         replace);
 }
 
 void RenderView::DidReceiveDocumentData(WebFrame* frame, const char* data,
                                         size_t data_len) {
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetDataSource());
+      NavigationState::FromDataSource(frame->dataSource());
   if (!navigation_state->postpone_loading_data()) {
-    frame->CommitDocumentData(data, data_len);
+    frame->commitDocumentData(data, data_len);
     return;
   }
 
   // Continue buffering the response data for the original 404 page.  If it
   // grows too large, then we'll just let it through.
   navigation_state->append_postponed_data(data, data_len);
   if (navigation_state->postponed_data().size() >= 512) {
     navigation_state->set_postpone_loading_data(false);
-    frame->CommitDocumentData(navigation_state->postponed_data().data(),
+    frame->commitDocumentData(navigation_state->postponed_data().data(),
                               navigation_state->postponed_data().size());
     navigation_state->clear_postponed_data();
   }
 }
 
 void RenderView::DidCommitLoadForFrame(WebView *webview, WebFrame* frame,
                                        bool is_new_navigation) {
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetDataSource());
+      NavigationState::FromDataSource(frame->dataSource());
 
   navigation_state->set_commit_load_time(Time::Now());
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the previous session
     // history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
@@ skipping 41 matching lines @@
 void RenderView::DidReceiveTitle(WebView* webview,
                                  const std::wstring& title,
                                  WebFrame* frame) {
   UpdateTitle(frame, title);
 
   // Also check whether we have new encoding name.
   UpdateEncoding(frame, webview->GetMainFrameEncodingName());
 }
 
 void RenderView::DidFinishLoadForFrame(WebView* webview, WebFrame* frame) {
-  WebDataSource* ds = frame->GetDataSource();
+  WebDataSource* ds = frame->dataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
   navigation_state->set_finish_load_time(Time::Now());
 }
 
 void RenderView::DidFailLoadWithError(WebView* webview,
                                       const WebURLError& error,
                                       WebFrame* frame) {
   // Currently this function is empty. When you implement something here and it
   // will display any error messages in HTML, please make sure to call
   // frame->SetInViewSourceMode(false) not to show them in view source mode.
 }
 
 void RenderView::DidFinishDocumentLoadForFrame(WebView* webview,
                                                WebFrame* frame) {
-  WebDataSource* ds = frame->GetDataSource();
+  WebDataSource* ds = frame->dataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
   navigation_state->set_finish_document_load_time(Time::Now());
 
   Send(new ViewHostMsg_DocumentLoadedInFrame(routing_id_));
 
   // The document has now been fully loaded.  Scan for password forms to be
   // sent up to the browser.
   SendPasswordForms(frame);
 
@@ skipping 12 matching lines @@
 void RenderView::DidChangeLocationWithinPageForFrame(WebView* webview,
                                                      WebFrame* frame,
                                                      bool is_new_navigation) {
   // If this was a reference fragment navigation that we initiated, then we
   // could end up having a non-null pending navigation state.  We just need to
   // update the ExtraData on the datasource so that others who read the
   // ExtraData will get the new NavigationState.  Similarly, if we did not
   // initiate this navigation, then we need to take care to reset any pre-
   // existing navigation state to a content-initiated navigation state.
   // DidCreateDataSource conveniently takes care of this for us.
-  DidCreateDataSource(frame, frame->GetDataSource());
+  DidCreateDataSource(frame, frame->dataSource());
 
   DidCommitLoadForFrame(webview, frame, is_new_navigation);
 
   const string16& title =
-      webview->GetMainFrame()->GetDataSource()->pageTitle();
+      webview->GetMainFrame()->dataSource()->pageTitle();
   UpdateTitle(frame, UTF16ToWideHack(title));
 }
 
 void RenderView::DidCompleteClientRedirect(WebView* webview,
                                            WebFrame* frame,
                                            const GURL& source) {
   if (webview->GetMainFrame() == frame)
     completed_client_redirect_src_ = source;
 }
 
 void RenderView::WillCloseFrame(WebView* webview, WebFrame* frame) {
-  if (!frame->GetParent()) {
-    const GURL& url = frame->GetURL();
+  if (!frame->parent()) {
+    const GURL& url = frame->url();
     if (url.SchemeIs("http") || url.SchemeIs("https"))
       DumpLoadHistograms();
   }
 }
 
 void RenderView::WillSubmitForm(WebView* webview, WebFrame* frame,
                                 const WebForm& form) {
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetProvisionalDataSource());
+      NavigationState::FromDataSource(frame->provisionalDataSource());
 
   if (navigation_state->transition_type() == PageTransition::LINK)
     navigation_state->set_transition_type(PageTransition::FORM_SUBMIT);
 
   // Save these to be processed when the ensuing navigation is committed.
   navigation_state->set_searchable_form_data(
       SearchableFormData::Create(form));
   navigation_state->set_password_form_data(
       PasswordFormDomManager::CreatePasswordForm(form));
 
@@ skipping 13 matching lines @@
 void RenderView::DidReceiveResponse(WebFrame* frame, uint32 identifier,
                                     const WebURLResponse& response) {
   // Consider loading an alternate error page for 404 responses.
   if (response.httpStatusCode() != 404)
     return;
 
   // Only do this for responses that correspond to a provisional data source
   // of the top-most frame.  If we have a provisional data source, then we
   // can't have any sub-resources yet, so we know that this response must
   // correspond to a frame load.
-  if (!frame->GetProvisionalDataSource() || frame->GetParent())
+  if (!frame->provisionalDataSource() || frame->parent())
     return;
 
   // If we are in view source mode, then just let the user see the source of
   // the server's 404 error page.
-  if (frame->GetInViewSourceMode())
+  if (frame->isViewSourceModeEnabled())
     return;
 
   // Can we even load an alternate error page for this URL?
   if (!GetAlternateErrorPageURL(response.url(), HTTP_404).is_valid())
     return;
 
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetProvisionalDataSource());
+      NavigationState::FromDataSource(frame->provisionalDataSource());
   navigation_state->set_postpone_loading_data(true);
   navigation_state->clear_postponed_data();
 }
 
 void RenderView::DidFinishLoading(WebFrame* frame, uint32 identifier) {
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetDataSource());
+      NavigationState::FromDataSource(frame->dataSource());
   if (!navigation_state->postpone_loading_data())
     return;
 
   // The server returned a 404 and the content was < 512 bytes (which we
   // suppressed).  Go ahead and fetch the alternate page content.
 
-  const GURL& frame_url = frame->GetURL();
+  const GURL& frame_url = frame->url();
 
   const GURL& error_page_url = GetAlternateErrorPageURL(frame_url, HTTP_404);
   DCHECK(error_page_url.is_valid());
 
   WebURLError original_error;
   original_error.unreachableURL = frame_url;
 
   navigation_state->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
           error_page_url, frame, original_error,
@@ skipping 20 matching lines @@
     external_host_bindings_.set_routing_id(routing_id_);
     external_host_bindings_.BindToJavascript(frame, L"externalHost");
   }
 }
 
 void RenderView::DocumentElementAvailable(WebFrame* frame) {
   // TODO(mpcomplete): remove this before Chrome extensions ship.
   // HACK.  This is a temporary workaround to allow cross-origin XHR for Chrome
   // extensions.  It grants full access to every origin, when we really want
   // to be able to restrict them more specifically.
-  GURL url = frame->GetURL();
+  GURL url = frame->url();
   if (url.SchemeIs(chrome::kExtensionScheme))
-    frame->GrantUniversalAccess();
+    frame->grantUniversalAccess();
 
   if (RenderThread::current())  // Will be NULL during unit tests.
     RenderThread::current()->user_script_slave()->InjectScripts(
         frame, UserScript::DOCUMENT_START);
 
   // Notify the browser about non-blank documents loading in the top frame.
   if (url.is_valid() && url.spec() != "about:blank") {
     if (frame == webview()->GetMainFrame())
       Send(new ViewHostMsg_DocumentAvailableInMainFrame(routing_id_));
   }
@@ skipping 24 matching lines @@
   const GURL& url = request.url();
 
   // If the browser is interested, then give it a chance to look at top level
   // navigations
   if (renderer_preferences_.browser_handles_top_level_requests &&
       // Only send once.
       last_top_level_navigation_page_id_ != page_id_ &&
       // Not interested in reloads.
       type != WebKit::WebNavigationTypeReload &&
       // Must be a top level frame.
-      frame->GetParent() == NULL) {
+      frame->parent() == NULL) {
     // Skip if navigation is on the same page (using '#').
-    GURL frame_origin = frame->GetURL().GetOrigin();
+    GURL frame_origin = GURL(frame->url()).GetOrigin();
     if (url.GetOrigin() != frame_origin || url.ref().empty()) {
       last_top_level_navigation_page_id_ = page_id_;
       OpenURL(webview, url, GURL(), default_policy);
       return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
   bool is_content_initiated =
-      NavigationState::FromDataSource(frame->GetProvisionalDataSource())->
+      NavigationState::FromDataSource(frame->provisionalDataSource())->
           is_content_initiated();
 
   // We only care about navigations that are within the current tab (as opposed
   // to, for example, opening a new window).
   // But we sometimes navigate to about:blank to clear a tab, and we want to
   // still allow that.
   if (default_policy == WebKit::WebNavigationPolicyCurrentTab &&
-      is_content_initiated && frame->GetParent() == NULL &&
+      is_content_initiated && frame->parent() == NULL &&
       !url.SchemeIs(chrome::kAboutScheme)) {
     // When we received such unsolicited navigations, we sometimes want to
     // punt them up to the browser to handle.
     if (BindingsPolicy::is_dom_ui_enabled(enabled_bindings_) ||
         BindingsPolicy::is_extension_enabled(enabled_bindings_) ||
-        frame->GetInViewSourceMode() ||
+        frame->isViewSourceModeEnabled() ||
         url.SchemeIs(chrome::kViewSourceScheme) ||
         url.SchemeIs(chrome::kPrintScheme)) {
       OpenURL(webview, url, GURL(), default_policy);
       return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
 
   // Detect when a page is "forking" a new tab that can be safely rendered in
   // its own process.  This is done by sites like Gmail that try to open links
   // in new windows without script connections back to the original page.  We
   // treat such cases as browser navigations (in which we will create a new
   // renderer for a cross-site navigation), rather than WebKit navigations.
   //
   // We use the following heuristic to decide whether to fork a new page in its
   // own process:
   // The parent page must open a new tab to about:blank, set the new tab's
   // window.opener to null, and then redirect the tab to a cross-site URL using
   // JavaScript.
   bool is_fork =
       // Must start from a tab showing about:blank, which is later redirected.
-      frame->GetURL() == GURL("about:blank") &&
+      GURL(frame->url()) == GURL("about:blank") &&
       // Must be the first real navigation of the tab.
       GetHistoryBackListCount() < 1 &&
       GetHistoryForwardListCount() < 1 &&
       // The parent page must have set the child's window.opener to null before
       // redirecting to the desired URL.
-      frame->GetOpener() == NULL &&
+      frame->opener() == NULL &&
       // Must be a top-level frame.
-      frame->GetParent() == NULL &&
+      frame->parent() == NULL &&
       // Must not have issued the request from this page.
       is_content_initiated &&
       // Must be targeted at the current tab.
       default_policy == WebKit::WebNavigationPolicyCurrentTab &&
       // Must be a JavaScript navigation, which appears as "other".
       type == WebKit::WebNavigationTypeOther;
   if (is_fork) {
     // Open the URL via the browser, not via WebKit.
     OpenURL(webview, url, GURL(), default_policy);
     return WebKit::WebNavigationPolicyIgnore;
   }
 
   return default_policy;
 }
 
 void RenderView::RunJavaScriptAlert(WebFrame* webframe,
                                     const std::wstring& message) {
   RunJavaScriptMessage(MessageBoxFlags::kIsJavascriptAlert,
                        message,
                        std::wstring(),
-                       webframe->GetURL(),
+                       webframe->url(),
                        NULL);
 }
 
 bool RenderView::RunJavaScriptConfirm(WebFrame* webframe,
                                       const std::wstring& message) {
   return RunJavaScriptMessage(MessageBoxFlags::kIsJavascriptConfirm,
                               message,
                               std::wstring(),
-                              webframe->GetURL(),
+                              webframe->url(),
                               NULL);
 }
 
 bool RenderView::RunJavaScriptPrompt(WebFrame* webframe,
                                      const std::wstring& message,
                                      const std::wstring& default_value,
                                      std::wstring* result) {
   return RunJavaScriptMessage(MessageBoxFlags::kIsJavascriptPrompt,
                               message,
                               default_value,
-                              webframe->GetURL(),
+                              webframe->url(),
                               result);
 }
 
 bool RenderView::RunJavaScriptMessage(int type,
                                       const std::wstring& message,
                                       const std::wstring& default_value,
                                       const GURL& frame_url,
                                       std::wstring* result) {
   bool success = false;
   std::wstring result_temp;
@@ skipping 14 matching lines @@
                                      autodetected));
 }
 
 bool RenderView::RunBeforeUnloadConfirm(WebFrame* webframe,
                                         const std::wstring& message) {
   bool success = false;
   // This is an ignored return value, but is included so we can accept the same
   // response as RunJavaScriptMessage.
   std::wstring ignored_result;
   IPC::SyncMessage* msg = new ViewHostMsg_RunBeforeUnloadConfirm(
-      routing_id_, webframe->GetURL(), message, &success,  &ignored_result);
+      routing_id_, webframe->url(), message, &success,  &ignored_result);
 
   msg->set_pump_messages_event(modal_dialog_event_.get());
   Send(msg);
 
   return success;
 }
 
 void RenderView::QueryFormFieldAutofill(const std::wstring& field_name,
                                         const std::wstring& text,
                                         int64 node_id) {
@@ skipping 157 matching lines @@
     WebView* webview,
     const GURL& url,
     const std::string& mime_type,
     const std::string& clsid,
     std::string* actual_mime_type) {
   if (!PluginChannelHost::IsListening())
     return NULL;
 
   GURL policy_url;
   if (webview->GetMainFrame())
-    policy_url = webview->GetMainFrame()->GetURL();
+    policy_url = webview->GetMainFrame()->url();
 
   FilePath path;
   render_thread_->Send(
       new ViewHostMsg_GetPluginPath(url, policy_url, mime_type, clsid, &path,
                                     actual_mime_type));
   if (path.value().empty())
     return NULL;
 
   std::string mime_type_to_use;
   if (!actual_mime_type->empty())
@@ skipping 98 matching lines @@
   // message.
   // TODO(rafaelw): Figure out where the best place to set this for extensions
   // is. It isn't clean to test for ExtensionView by examining the
   // enabled_bindings. This needs to be generalized as it becomes clear what
   // extension toolbars need.
   if (BindingsPolicy::is_extension_enabled(enabled_bindings_) ||
       send_preferred_width_changes_) {
     // WebCore likes to tell us things have changed even when they haven't, so
     // cache the width and only send the IPC message when we're sure the
     // width is different.
-    int width = webview()->GetMainFrame()->GetContentsPreferredWidth();
+    int width = webview()->GetMainFrame()->contentsPreferredWidth();
     if (width != preferred_width_) {
       Send(new ViewHostMsg_DidContentsPreferredWidthChange(routing_id_, width));
       preferred_width_ = width;
     }
   }
 }
 
 // We are supposed to get a single call to Show for a newly created RenderView
 // that was created via RenderView::CreateWebView.  So, we wait until this
 // point to dispatch the ShowView message.
@@ skipping 29 matching lines @@
   IPC::SyncMessage* msg = new ViewHostMsg_RunModal(routing_id_);
 
   msg->set_pump_messages_event(modal_dialog_event_.get());
   Send(msg);
 }
 
 void RenderView::SyncNavigationState() {
   if (!webview())
     return;
 
-  const WebHistoryItem& item =
-      webview()->GetMainFrame()->GetCurrentHistoryItem();
+  const WebHistoryItem& item = webview()->GetMainFrame()->currentHistoryItem();
   if (item.isNull())
     return;
 
   Send(new ViewHostMsg_UpdateState(
       routing_id_, page_id_, webkit_glue::HistoryItemToString(item)));
 }
 
 void RenderView::ShowContextMenu(WebView* webview,
                                  ContextNodeType node_type,
                                  int x,
@@ skipping 14 matching lines @@
   params.y = y;
   params.src_url = src_url;
   params.link_url = link_url;
   params.unfiltered_link_url = link_url;
   params.page_url = page_url;
   params.frame_url = frame_url;
   params.media_params = media_params;
   params.selection_text = selection_text;
   params.misspelled_word = misspelled_word;
   params.spellcheck_enabled =
-      webview->GetFocusedFrame()->SpellCheckEnabled();
+      webview->GetFocusedFrame()->isContinuousSpellCheckingEnabled();
   params.edit_flags = edit_flags;
   params.security_info = security_info;
   params.frame_charset = frame_charset;
   Send(new ViewHostMsg_ContextMenu(routing_id_, params));
 }
 
 void RenderView::StartDragging(WebView* webview,
                                const WebDragData& drag_data) {
   Send(new ViewHostMsg_StartDragging(routing_id_, WebDropData(drag_data)));
 }
@@ skipping 126 matching lines @@
   bool multi_frame = (frame_after_main != main_frame);
 
   // If we have multiple frames, we don't want to wrap the search within the
   // frame, so we check here if we only have main_frame in the chain.
   bool wrap_within_frame = !multi_frame;
 
   WebRect selection_rect;
   bool result = false;
 
   do {
-    result = search_frame->Find(
+    result = search_frame->find(
         request_id, search_text, options, wrap_within_frame, &selection_rect);
 
     if (!result) {
       // don't leave text selected as you move to the next frame.
-      search_frame->ClearSelection();
+      search_frame->clearSelection();
 
       // Find the next frame, but skip the invisible ones.
       do {
         // What is the next frame to search? (we might be going backwards). Note
         // that we specify wrap=true so that search_frame never becomes NULL.
         search_frame = options.forward ?
             webview()->GetNextFrameAfter(search_frame, true) :
             webview()->GetPreviousFrameBefore(search_frame, true);
-      } while (!search_frame->Visible() && search_frame != focused_frame);
+      } while (!search_frame->hasVisibleContent() &&
+               search_frame != focused_frame);
 
       // Make sure selection doesn't affect the search operation in new frame.
-      search_frame->ClearSelection();
+      search_frame->clearSelection();
 
       // If we have multiple frames and we have wrapped back around to the
       // focused frame, we need to search it once more allowing wrap within
       // the frame, otherwise it will report 'no match' if the focused frame has
       // reported matches, but no frames after the focused_frame contain a
       // match for the search word(s).
       if (multi_frame && search_frame == focused_frame) {
-        result = search_frame->Find(
+        result = search_frame->find(
             request_id, search_text, options, true,  // Force wrapping.
             &selection_rect);
       }
     }
 
     webview()->SetFocusedFrame(search_frame);
   } while (!result && search_frame != focused_frame);
 
   if (options.findNext) {
     // Force the main_frame to report the actual count.
-    main_frame->IncreaseMatchCount(0, request_id);
+    main_frame->increaseMatchCount(0, request_id);
   } else {
     // If nothing is found, set result to "0 of 0", otherwise, set it to
     // "-1 of 1" to indicate that we found at least one item, but we don't know
     // yet what is active.
     int ordinal = result ? -1 : 0;  // -1 here means, we might know more later.
     int match_count = result ? 1 : 0;  // 1 here means possibly more coming.
 
     // If we find no matches then this will be our last status update.
     // Otherwise the scoping effort will send more results.
     bool final_status_update = !result;
 
     // Send the search result over to the browser process.
     Send(new ViewHostMsg_Find_Reply(routing_id_,
                                     request_id,
                                     match_count,
                                     selection_rect,
                                     ordinal,
                                     final_status_update));
 
     // Scoping effort begins, starting with the mainframe.
     search_frame = main_frame;
 
-    main_frame->ResetMatchCount();
+    main_frame->resetMatchCount();
 
     do {
       // Cancel all old scoping requests before starting a new one.
-      search_frame->CancelPendingScopingEffort();
+      search_frame->cancelPendingScopingEffort();
 
       // We don't start another scoping effort unless at least one match has
       // been found.
       if (result) {
         // Start new scoping request. If the scoping function determines that it
         // needs to scope, it will defer until later.
-        search_frame->ScopeStringMatches(request_id,
+        search_frame->scopeStringMatches(request_id,
                                          search_text,
                                          options,
                                          true);  // reset the tickmarks
       }
 
       // Iterate to the next frame. The frame will not necessarily scope, for
       // example if it is not visible.
       search_frame = webview()->GetNextFrameAfter(search_frame, true);
     } while (search_frame != main_frame);
   }
@@ skipping 116 matching lines @@
       break;
     default:
       NOTREACHED();
   }
 }
 
 void RenderView::OnInsertText(const string16& text) {
   WebFrame* frame = webview()->GetFocusedFrame();
   if (!frame)
     return;
-  WebTextInput* text_input = frame->GetTextInput();
-  if (text_input)
-    text_input->InsertText(text);
+  frame->insertText(text);
 }
 
 void RenderView::OnSetPageEncoding(const std::wstring& encoding_name) {
   webview()->SetPageEncoding(encoding_name);
 }
 
 void RenderView::NavigateBackForwardSoon(int offset) {
   history_back_list_count_ += offset;
   history_forward_list_count_ -= offset;
 
@@ skipping 25 matching lines @@
 
 void RenderView::DidChangeSelection(bool is_empty_selection) {
 #if defined(OS_LINUX)
   // TODO(estade): investigate incremental updates to the selection so that we
   // don't send the entire selection over IPC every time.
   if (!is_empty_selection) {
     // Sometimes we get repeated DidChangeSelection calls from webkit when
     // the selection hasn't actually changed. We don't want to report these
     // because it will cause us to continually claim the X clipboard.
     const std::string& this_selection =
-        webview()->GetFocusedFrame()->GetSelection(false);
+        webview()->GetFocusedFrame()->selectionAsText().utf8();
     if (this_selection == last_selection_)
       return;
 
     Send(new ViewHostMsg_SelectionChanged(routing_id_,
          this_selection));
     last_selection_ = this_selection;
   } else {
     last_selection_.clear();
   }
 #endif
 }
 
 void RenderView::DownloadUrl(const GURL& url, const GURL& referrer) {
   Send(new ViewHostMsg_DownloadUrl(routing_id_, url, referrer));
 }
 
 void RenderView::UpdateInspectorSettings(const std::wstring& raw_settings) {
   Send(new ViewHostMsg_UpdateInspectorSettings(routing_id_, raw_settings));
 }
 
 WebDevToolsAgentDelegate* RenderView::GetWebDevToolsAgentDelegate() {
   return devtools_agent_.get();
 }
 
 void RenderView::PasteFromSelectionClipboard() {
   Send(new ViewHostMsg_PasteFromSelectionClipboard(routing_id_));
 }
 
-WebFrame* RenderView::GetChildFrame(const std::wstring& frame_xpath) const {
-  WebFrame* web_frame;
-  if (frame_xpath.empty()) {
-    web_frame = webview()->GetMainFrame();
-  } else {
-    web_frame = webview()->GetMainFrame()->GetChildFrame(frame_xpath);
+WebFrame* RenderView::GetChildFrame(const std::wstring& xpath) const {
+  if (xpath.empty())
+    return webview()->GetMainFrame();
+
+  // xpath string can represent a frame deep down the tree (across multiple
+  // frame DOMs).
+  // Example, /html/body/table/tbody/tr/td/iframe\n/frameset/frame[0]
+  // should break into 2 xpaths
+  // /html/body/table/tbody/tr/td/iframe & /frameset/frame[0]
+
+  WebFrame* frame = webview()->GetMainFrame();
+
+  std::wstring xpath_remaining = xpath;
+  while (!xpath_remaining.empty()) {
+    std::wstring::size_type delim_pos = xpath_remaining.find_first_of(L'\n');
+    std::wstring xpath_child;
+    if (delim_pos != std::wstring::npos) {
+      xpath_child = xpath_remaining.substr(0, delim_pos);
+      xpath_remaining.erase(0, delim_pos + 1);
+    } else {
+      xpath_remaining.swap(xpath_child);
+    }
+    frame = frame->findChildByExpression(WideToUTF16Hack(xpath_child));
   }
 
-  return web_frame;
+  return frame;
 }
 
 void RenderView::EvaluateScript(const std::wstring& frame_xpath,
                                 const std::wstring& script) {
   WebFrame* web_frame = GetChildFrame(frame_xpath);
   if (!web_frame)
     return;
 
-  web_frame->ExecuteScript(WebScriptSource(WideToUTF16Hack(script)));
+  web_frame->executeScript(WebScriptSource(WideToUTF16Hack(script)));
 }
 
 void RenderView::InsertCSS(const std::wstring& frame_xpath,
                            const std::string& css) {
   WebFrame* web_frame = GetChildFrame(frame_xpath);
   if (!web_frame)
     return;
 
-  web_frame->InsertCSSStyles(css);
+  web_frame->insertStyleText(WebString::fromUTF8(css));
 }
 
 void RenderView::OnScriptEvalRequest(const std::wstring& frame_xpath,
                                      const std::wstring& jscript) {
   EvaluateScript(frame_xpath, jscript);
 }
 
 void RenderView::OnCSSInsertRequest(const std::wstring& frame_xpath,
                                     const std::string& css) {
   InsertCSS(frame_xpath, css);
 
   // Notify RenderViewHost that css has been inserted into the frame.
   Send(new ViewHostMsg_OnCSSInserted(routing_id_));
 }
 
 void RenderView::OnAddMessageToConsole(
     const string16& frame_xpath,
     const string16& message,
     const WebConsoleMessage::Level& level) {
   WebFrame* web_frame = GetChildFrame(UTF16ToWideHack(frame_xpath));
   if (web_frame)
-    web_frame->AddMessageToConsole(WebConsoleMessage(level, message));
+    web_frame->addMessageToConsole(WebConsoleMessage(level, message));
 }
 
 void RenderView::OnAllowBindings(int enabled_bindings_flags) {
   enabled_bindings_ |= enabled_bindings_flags;
 }
 
 void RenderView::OnSetDOMUIProperty(const std::string& name,
                                     const std::string& value) {
   DCHECK(BindingsPolicy::is_dom_ui_enabled(enabled_bindings_));
   dom_ui_bindings_.SetProperty(name, value);
@@ skipping 120 matching lines @@
   file_chooser_.reset();
 }
 
 void RenderView::OnEnableViewSourceMode() {
   if (!webview())
     return;
   WebFrame* main_frame = webview()->GetMainFrame();
   if (!main_frame)
     return;
 
-  main_frame->SetInViewSourceMode(true);
+  main_frame->enableViewSourceMode(true);
 }
 
 void RenderView::OnEnableIntrinsicWidthChangedMode() {
   send_preferred_width_changes_ = true;
 }
 
 void RenderView::OnSetRendererPrefs(const RendererPreferences& renderer_prefs) {
   renderer_preferences_ = renderer_prefs;
   UpdateFontRenderingFromRendererPrefs();
 }
@@ skipping 102 matching lines @@
 void RenderView::OnClosePage(const ViewMsg_ClosePage_Params& params) {
   // TODO(creis): We'd rather use webview()->Close() here, but that currently
   // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
   // in the onunload handler from appearing.  For now, we're bypassing that and
   // calling the FrameLoader's CloseURL method directly.  This should be
   // revisited to avoid having two ways to close a page.  Having a single way
   // to close that can run onunload is also useful for fixing
   // http://b/issue?id=753080.
   WebFrame* main_frame = webview()->GetMainFrame();
   if (main_frame) {
-    const GURL& url = main_frame->GetURL();
+    const GURL& url = main_frame->url();
     // TODO(davemoore) this code should be removed once WillCloseFrame() gets
     // called when a page is destroyed. DumpLoadHistograms() is safe to call
     // multiple times for the same frame, but it will simplify things.
-    if (url.SchemeIs(chrome::kHttpScheme) || url.SchemeIs(chrome::kHttpsScheme))
+    if (url.SchemeIs(chrome::kHttpScheme) ||
+        url.SchemeIs(chrome::kHttpsScheme))
       DumpLoadHistograms();
   }
   webview()->ClosePage();
 
   // Just echo back the params in the ACK.
   Send(new ViewHostMsg_ClosePage_ACK(routing_id_, params));
 }
 
 void RenderView::OnThemeChanged() {
 #if defined(OS_WIN)
   gfx::NativeTheme::instance()->CloseHandles();
   gfx::Rect view_rect(0, 0, size_.width(), size_.height());
   didInvalidateRect(view_rect);
 #else  // defined(OS_WIN)
   // TODO(port): we don't support theming on non-Windows platforms yet
   NOTIMPLEMENTED();
 #endif
 }
 
 void RenderView::DidAddHistoryItem() {
   // We don't want to update the history length for the start page
   // navigation.
   WebFrame* main_frame = webview()->GetMainFrame();
   DCHECK(main_frame != NULL);
 
-  WebDataSource* ds = main_frame->GetDataSource();
+  WebDataSource* ds = main_frame->dataSource();
   DCHECK(ds != NULL);
 
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
   if (navigation_state->transition_type() == PageTransition::START_PAGE)
     return;
 
   history_back_list_count_++;
   history_forward_list_count_ = 0;
 }
@@ skipping 16 matching lines @@
 }
 
 bool RenderView::MaybeLoadAlternateErrorPage(WebFrame* frame,
                                              const WebURLError& error,
                                              bool replace) {
   // We only show alternate error pages in the main frame.  They are
   // intended to assist the user when navigating, so there is not much
   // value in showing them for failed subframes.  Ideally, we would be
   // able to use the TYPED transition type for this, but that flag is
   // not preserved across page reloads.
-  if (frame->GetParent())
+  if (frame->parent())
     return false;
 
   // Use the alternate error page service if this is a DNS failure or
   // connection failure.
   int ec = error.reason;
   if (ec != net::ERR_NAME_NOT_RESOLVED &&
       ec != net::ERR_CONNECTION_FAILED &&
       ec != net::ERR_CONNECTION_REFUSED &&
       ec != net::ERR_ADDRESS_UNREACHABLE &&
       ec != net::ERR_CONNECTION_TIMED_OUT)
     return false;
 
   const GURL& error_page_url = GetAlternateErrorPageURL(error.unreachableURL,
       ec == net::ERR_NAME_NOT_RESOLVED ? DNS_ERROR : CONNECTION_ERROR);
   if (!error_page_url.is_valid())
     return false;
 
   // Load an empty page first so there is an immediate response to the error,
   // and then kick off a request for the alternate error page.
-  frame->LoadHTMLString(std::string(),
+  frame->loadHTMLString(std::string(),
                         GURL(kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 
   // Now, create a fetcher for the error page and associate it with the data
   // source we just created via the LoadHTMLString call.  That way if another
   // navigation occurs, the fetcher will get destroyed.
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(frame->GetProvisionalDataSource());
+      NavigationState::FromDataSource(frame->provisionalDataSource());
   navigation_state->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
           error_page_url, frame, error,
           NewCallback(this, &RenderView::AltErrorPageFinished)));
   return true;
 }
 
 std::string RenderView::GetAltHTMLForTemplate(
     const DictionaryValue& error_strings, int template_resource_id) const {
   const StringPiece template_html(
@@ skipping 14 matching lines @@
                                       const WebURLError& original_error,
                                       const std::string& html) {
   // Here, we replace the blank page we loaded previously.
 
   // If we failed to download the alternate error page, fall back to the
   // original error page if present.  Otherwise, LoadNavigationErrorPage
   // will simply display a default error page.
   const std::string* html_to_load = &html;
   if (html.empty()) {
     NavigationState* navigation_state =
-        NavigationState::FromDataSource(frame->GetDataSource());
+        NavigationState::FromDataSource(frame->dataSource());
     html_to_load = &navigation_state->postponed_data();
   }
   LoadNavigationErrorPage(
       frame, WebURLRequest(), original_error, *html_to_load, true);
 }
 
 void RenderView::OnMoveOrResizeStarted() {
   if (webview())
     webview()->HideAutofillPopup();
 }
@@ skipping 71 matching lines @@
 //    commit->first_paint_after_load,
 //    finish->first_paint_after_load,
 //
 // It's possible for the request time not to be set, if a client
 // redirect had been done (the user never requested the page)
 // Also, it's possible to load a page without ever laying it out
 // so first_paint and first_paint_after_load can be 0.
 void RenderView::DumpLoadHistograms() const {
   WebFrame* main_frame = webview()->GetMainFrame();
   NavigationState* navigation_state =
-      NavigationState::FromDataSource(main_frame->GetDataSource());
+      NavigationState::FromDataSource(main_frame->dataSource());
   Time finish = navigation_state->finish_load_time();
 
   // If we've already dumped or we haven't finished loading, do nothing.
   if (navigation_state->load_histograms_recorded() || finish.is_null())
     return;
 
   Time request = navigation_state->request_time();
   Time start = navigation_state->start_load_time();
   Time commit = navigation_state->commit_load_time();
   Time finish_doc = navigation_state->finish_document_load_time();
@@ skipping 155 matching lines @@
 
 void RenderView::DidMovePlugin(const WebPluginGeometry& move) {
   SchedulePluginMove(move);
 }
 
 void RenderView::WillDestroyPluginWindow(gfx::PluginWindowHandle window) {
   CleanupWindowInPluginMoves(window);
 }
 
 void RenderView::SendPasswordForms(WebFrame* frame) {
-  std::vector<WebForm> forms;
-  frame->GetForms(&forms);
+  WebVector<WebForm> forms;
+  frame->forms(forms);
 
   std::vector<PasswordForm> password_forms;
   for (size_t i = 0; i < forms.size(); ++i) {
     const WebForm& form = forms[i];
 
     // Respect autocomplete=off.
     if (form.isAutoCompleteEnabled()) {
       scoped_ptr<PasswordForm> password_form(
           PasswordFormDomManager::CreatePasswordForm(form));
       if (password_form.get())
         password_forms.push_back(*password_form);
     }
   }
 
   if (!password_forms.empty())
     Send(new ViewHostMsg_PasswordFormsSeen(routing_id_, password_forms));
 }
 
 void RenderView::Print(WebFrame* frame, bool script_initiated) {
   DCHECK(frame);
   if (print_helper_.get() == NULL) {
     print_helper_.reset(new PrintWebViewHelper(this));
   }
   print_helper_->Print(frame, script_initiated);
 }