Switch to WebFrame from the WebKit API....

webkit/glue/webframe_impl.cc

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 130 matching lines @@
 #include "base/message_loop.h"
 #include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/platform_canvas.h"
 #include "webkit/api/public/WebConsoleMessage.h"
 #include "webkit/api/public/WebFindOptions.h"
 #include "webkit/api/public/WebForm.h"
 #include "webkit/api/public/WebHistoryItem.h"
+#include "webkit/api/public/WebRange.h"
 #include "webkit/api/public/WebRect.h"
 #include "webkit/api/public/WebScriptSource.h"
 #include "webkit/api/public/WebSize.h"
 #include "webkit/api/public/WebURLError.h"
+#include "webkit/api/public/WebVector.h"
 #include "webkit/glue/chrome_client_impl.h"
 #include "webkit/glue/dom_operations.h"
 #include "webkit/glue/dom_operations_private.h"
 #include "webkit/glue/glue_util.h"
 #include "webkit/glue/webdatasource_impl.h"
 #include "webkit/glue/webframe_impl.h"
-#include "webkit/glue/webtextinput_impl.h"
 #include "webkit/glue/webview_impl.h"
 
 #if defined(OS_LINUX)
 #include <gdk/gdk.h>
 #endif
 
 #if USE(JSC)
 #include "bridge/c/c_instance.h"
 #include "bridge/runtime_object.h"
 #endif
 
 using base::Time;
 
+using WebCore::AtomicString;
 using WebCore::ChromeClientChromium;
 using WebCore::Color;
 using WebCore::Document;
 using WebCore::DocumentFragment;
 using WebCore::DocumentLoader;
 using WebCore::ExceptionCode;
 using WebCore::GraphicsContext;
 using WebCore::HTMLFrameOwnerElement;
 using WebCore::Frame;
 using WebCore::FrameLoader;
@@ skipping 21 matching lines @@
 using WebCore::SubstituteData;
 using WebCore::TextIterator;
 using WebCore::VisiblePosition;
 using WebCore::XPathResult;
 
 using WebKit::WebCanvas;
 using WebKit::WebConsoleMessage;
 using WebKit::WebData;
 using WebKit::WebDataSource;
 using WebKit::WebFindOptions;
+using WebKit::WebFrame;
 using WebKit::WebHistoryItem;
 using WebKit::WebForm;
+using WebKit::WebRange;
 using WebKit::WebRect;
 using WebKit::WebScriptSource;
 using WebKit::WebSize;
 using WebKit::WebString;
 using WebKit::WebURL;
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
+using WebKit::WebVector;
 
 // Key for a StatsCounter tracking how many WebFrames are active.
 static const char* const kWebFrameActiveCount = "WebFrameActiveCount";
 
 static const char* const kOSDType = "application/opensearchdescription+xml";
 static const char* const kOSDRel = "search";
 
 // The separator between frames when the frames are converted to plain text.
 static const wchar_t kFrameSeparator[] = L"\n\n";
-static const int kFrameSeparatorLen = arraysize(kFrameSeparator) - 1;
+static const size_t kFrameSeparatorLen = arraysize(kFrameSeparator) - 1;
 
-// Backend for GetContentAsPlainText, this is a recursive function that gets
+// Backend for contentAsPlainText, this is a recursive function that gets
 // the text for the current frame and all of its subframes. It will append
 // the text of each frame in turn to the |output| up to |max_chars| length.
 //
 // The |frame| must be non-NULL.
-static void FrameContentAsPlainText(int max_chars, Frame* frame,
+static void FrameContentAsPlainText(size_t max_chars, Frame* frame,
                                     std::wstring* output) {
   Document* doc = frame->document();
   if (!doc)
     return;
 
   if (!frame->view())
     return;
 
   // TextIterator iterates over the visual representation of the DOM. As such,
   // it requires you to do a layout before using it (otherwise it'll crash).
@@ skipping 25 matching lines @@
           // currently understand the conditions for this to occur. Ideally, the
           // iterators would never get into the condition so we should fix them
           // if we can.
           NOTREACHED();
           break;
         }
 
         // Just got a NULL node, we can forge ahead!
         continue;
       }
-      int to_append = std::min(it.length(),
-                               max_chars - static_cast<int>(output->size()));
+      size_t to_append = std::min(static_cast<size_t>(it.length()),
+                                  max_chars - output->size());
       std::wstring wstr;
       UTF16ToWide(reinterpret_cast<const char16*>(chars), to_append, &wstr);
       output->append(wstr.c_str(), to_append);
-      if (output->size() >= static_cast<size_t>(max_chars))
+      if (output->size() >= max_chars)
         return;  // Filled up the buffer.
     }
   }
 
   // Recursively walk the children.
   FrameTree* frame_tree = frame->tree();
   for (Frame* cur_child = frame_tree->firstChild(); cur_child;
        cur_child = cur_child->tree()->nextSibling()) {
     // Make sure the frame separator won't fill up the buffer, and give up if
     // it will. The danger is if the separator will make the buffer longer than
     // max_chars. This will cause the computation above:
     //   max_chars - output->size()
     // to be a negative number which will crash when the subframe is added.
-    if (static_cast<int>(output->size()) >= max_chars - kFrameSeparatorLen)
+    if (output->size() >= max_chars - kFrameSeparatorLen)
       return;
 
     output->append(kFrameSeparator, kFrameSeparatorLen);
     FrameContentAsPlainText(max_chars, cur_child, output);
-    if (output->size() >= static_cast<size_t>(max_chars))
+    if (output->size() >= max_chars)
       return;  // Filled up the buffer.
   }
 }
 
 // Simple class to override some of PrintContext behavior.
 class ChromePrintContext : public WebCore::PrintContext {
  public:
   ChromePrintContext(Frame* frame)
       : PrintContext(frame),
         printed_page_width_(0) {
@@ skipping 29 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromePrintContext);
 };
 
 // WebFrameImpl ----------------------------------------------------------------
 
 int WebFrameImpl::live_object_count_ = 0;
 
 // static
-WebFrame* WebFrame::RetrieveFrameForEnteredContext() {
-  WebCore::Frame* frame =
+WebFrame* WebFrame::frameForEnteredContext() {
+  Frame* frame =
       WebCore::ScriptController::retrieveFrameForEnteredContext();
   if (frame)
     return WebFrameImpl::FromFrame(frame);
   else
     return NULL;
 }
 
 // static
-WebFrame* WebFrame::RetrieveFrameForCurrentContext() {
-  WebCore::Frame* frame =
+WebFrame* WebFrame::frameForCurrentContext() {
+  Frame* frame =
       WebCore::ScriptController::retrieveFrameForCurrentContext();
   if (frame)
     return WebFrameImpl::FromFrame(frame);
   else
     return NULL;
 }
 
 WebFrameImpl::WebFrameImpl()
   : ALLOW_THIS_IN_INITIALIZER_LIST(frame_loader_client_(this)),
     ALLOW_THIS_IN_INITIALIZER_LIST(scope_matches_factory_(this)),
     plugin_delegate_(NULL),
     active_match_frame_(NULL),
     active_match_index_(-1),
     locating_active_rect_(false),
     resume_scoping_from_range_(NULL),
     last_match_count_(-1),
     total_matchcount_(-1),
     frames_scoping_count_(-1),
     scoping_complete_(false),
     next_invalidate_after_(0) {
   StatsCounter(kWebFrameActiveCount).Increment();
   live_object_count_++;
 }
 
 WebFrameImpl::~WebFrameImpl() {
   StatsCounter(kWebFrameActiveCount).Decrement();
   live_object_count_--;
 
-  CancelPendingScopingEffort();
+  cancelPendingScopingEffort();
   ClearPasswordListeners();
 }
 
 // WebFrame -------------------------------------------------------------------
 
 void WebFrameImpl::InitMainFrame(WebViewImpl* webview_impl) {
   RefPtr<Frame> frame =
       Frame::create(webview_impl->page(), 0, &frame_loader_client_);
   frame_ = frame.get();
 
   // Add reference on behalf of FrameLoader.  See comments in
   // WebFrameLoaderClient::frameLoaderDestroyed for more info.
   AddRef();
 
   // We must call init() after frame_ is assigned because it is referenced
   // during init().
   frame_->init();
 }
 
-void WebFrameImpl::Reload() {
+void WebFrameImpl::reload() {
   frame_->loader()->saveDocumentAndScrollState();
 
-  StopLoading();  // Make sure existing activity stops.
+  stopLoading();  // Make sure existing activity stops.
   frame_->loader()->reload();
 }
 
-void WebFrameImpl::LoadRequest(const WebURLRequest& request) {
+void WebFrameImpl::loadRequest(const WebURLRequest& request) {
   const ResourceRequest* resource_request =
       webkit_glue::WebURLRequestToResourceRequest(&request);
   DCHECK(resource_request);
 
   if (resource_request->url().protocolIs("javascript")) {
     LoadJavaScriptURL(resource_request->url());
     return;
   }
 
-  StopLoading();  // Make sure existing activity stops.
+  stopLoading();  // Make sure existing activity stops.
   frame_->loader()->load(*resource_request, false);
 }
 
-void WebFrameImpl::LoadHistoryItem(const WebHistoryItem& item) {
+void WebFrameImpl::loadHistoryItem(const WebHistoryItem& item) {
   RefPtr<HistoryItem> history_item =
       webkit_glue::WebHistoryItemToHistoryItem(item);
   DCHECK(history_item.get());
 
-  StopLoading();  // Make sure existing activity stops.
+  stopLoading();  // Make sure existing activity stops.
 
   // If there is no current_item, which happens when we are navigating in
   // session history after a crash, we need to manufacture one otherwise WebKit
   // hoarks. This is probably the wrong thing to do, but it seems to work.
   RefPtr<HistoryItem> current_item = frame_->loader()->currentHistoryItem();
   if (!current_item) {
     current_item = HistoryItem::create();
     current_item->setLastVisitWasFailure(true);
     frame_->loader()->setCurrentHistoryItem(current_item);
     GetWebViewImpl()->SetCurrentHistoryItem(current_item.get());
   }
 
   frame_->loader()->goToItem(history_item.get(),
                              WebCore::FrameLoadTypeIndexedBackForward);
 }
 
-void WebFrameImpl::LoadData(const WebData& data,
+void WebFrameImpl::loadData(const WebData& data,
                             const WebString& mime_type,
                             const WebString& text_encoding,
                             const WebURL& base_url,
                             const WebURL& unreachable_url,
                             bool replace) {
   SubstituteData subst_data(
       webkit_glue::WebDataToSharedBuffer(data),
       webkit_glue::WebStringToString(mime_type),
       webkit_glue::WebStringToString(text_encoding),
       webkit_glue::WebURLToKURL(unreachable_url));
   DCHECK(subst_data.isValid());
 
-  StopLoading();  // Make sure existing activity stops.
+  stopLoading();  // Make sure existing activity stops.
   frame_->loader()->load(ResourceRequest(webkit_glue::WebURLToKURL(base_url)),
                          subst_data, false);
   if (replace) {
     // Do this to force WebKit to treat the load as replacing the currently
     // loaded page.
     frame_->loader()->setReplacing();
   }
 }
 
-void WebFrameImpl::LoadHTMLString(const WebData& data,
+void WebFrameImpl::loadHTMLString(const WebData& data,
                                   const WebURL& base_url,
                                   const WebURL& unreachable_url,
                                   bool replace) {
-  LoadData(data,
+  loadData(data,
            WebString::fromUTF8("text/html"),
            WebString::fromUTF8("UTF-8"),
            base_url,
            unreachable_url,
            replace);
 }
 
-GURL WebFrameImpl::GetURL() const {
-  const WebDataSource* ds = GetDataSource();
+WebURL WebFrameImpl::url() const {
+  const WebDataSource* ds = dataSource();
   if (!ds)
-    return GURL();
+    return WebURL();
   return ds->request().url();
 }
 
-GURL WebFrameImpl::GetFavIconURL() const {
+WebURL WebFrameImpl::favIconURL() const {
   WebCore::FrameLoader* frame_loader = frame_->loader();
   // The URL to the favicon may be in the header. As such, only
   // ask the loader for the favicon if it's finished loading.
   if (frame_loader->state() == WebCore::FrameStateComplete) {
     const KURL& url = frame_loader->iconURL();
     if (!url.isEmpty()) {
-      return webkit_glue::KURLToGURL(url);
+      return webkit_glue::KURLToWebURL(url);
     }
   }
-  return GURL();
+  return WebURL();
 }
 
-GURL WebFrameImpl::GetOSDDURL() const {
+WebURL WebFrameImpl::openSearchDescriptionURL() const {
   WebCore::FrameLoader* frame_loader = frame_->loader();
   if (frame_loader->state() == WebCore::FrameStateComplete &&
       frame_->document() && frame_->document()->head() &&
       !frame_->tree()->parent()) {
     WebCore::HTMLHeadElement* head = frame_->document()->head();
     if (head) {
       RefPtr<WebCore::HTMLCollection> children = head->children();
       for (Node* child = children->firstItem(); child != NULL;
            child = children->nextItem()) {
         WebCore::HTMLLinkElement* link_element =
             webkit_glue::CastToHTMLLinkElement(child);
         if (link_element && link_element->type() == kOSDType &&
             link_element->rel() == kOSDRel && !link_element->href().isEmpty()) {
-          return webkit_glue::KURLToGURL(link_element->href());
+          return webkit_glue::KURLToWebURL(link_element->href());
         }
       }
     }
   }
-  return GURL();
+  return WebURL();
 }
 
-int WebFrameImpl::GetContentsPreferredWidth() const {
+int WebFrameImpl::contentsPreferredWidth() const {
   if ((frame_->document() != NULL) &&
       (frame_->document()->renderView() != NULL)) {
     return frame_->document()->renderView()->minPrefWidth();
   } else {
     return 0;
   }
 }
 
-WebHistoryItem WebFrameImpl::GetPreviousHistoryItem() const {
+WebHistoryItem WebFrameImpl::previousHistoryItem() const {
   // We use the previous item here because documentState (filled-out forms)
   // only get saved to history when it becomes the previous item.  The caller
   // is expected to query the history item after a navigation occurs, after
   // the desired history item has become the previous entry.
   return webkit_glue::HistoryItemToWebHistoryItem(
       GetWebViewImpl()->GetPreviousHistoryItem());
 }
 
-WebHistoryItem WebFrameImpl::GetCurrentHistoryItem() const {
+WebHistoryItem WebFrameImpl::currentHistoryItem() const {
   frame_->loader()->saveDocumentAndScrollState();
 
   return webkit_glue::HistoryItemToWebHistoryItem(
       frame_->page()->backForwardList()->currentItem());
 }
 
 static WebDataSource* DataSourceForDocLoader(DocumentLoader* loader) {
   return loader ? WebDataSourceImpl::FromLoader(loader) : NULL;
 }
 
-WebDataSource* WebFrameImpl::GetDataSource() const {
+WebDataSource* WebFrameImpl::dataSource() const {
   return DataSourceForDocLoader(frame_->loader()->documentLoader());
 }
 
 WebDataSourceImpl* WebFrameImpl::GetDataSourceImpl() const {
-  return static_cast<WebDataSourceImpl*>(GetDataSource());
+  return static_cast<WebDataSourceImpl*>(dataSource());
 }
 
-WebDataSource* WebFrameImpl::GetProvisionalDataSource() const {
+WebDataSource* WebFrameImpl::provisionalDataSource() const {
   FrameLoader* frame_loader = frame_->loader();
 
   // We regard the policy document loader as still provisional.
   DocumentLoader* doc_loader = frame_loader->provisionalDocumentLoader();
   if (!doc_loader)
     doc_loader = frame_loader->policyDocumentLoader();
 
   return DataSourceForDocLoader(doc_loader);
 }
 
 WebDataSourceImpl* WebFrameImpl::GetProvisionalDataSourceImpl() const {
-  return static_cast<WebDataSourceImpl*>(GetProvisionalDataSource());
+  return static_cast<WebDataSourceImpl*>(provisionalDataSource());
 }
 
-void WebFrameImpl::StopLoading() {
+void WebFrameImpl::stopLoading() {
   if (!frame_)
     return;
 
   // TODO(darin): Figure out what we should really do here.  It seems like a
   // bug that FrameLoader::stopLoading doesn't call stopAllLoaders.
   frame_->loader()->stopAllLoaders();
   frame_->loader()->stopLoading(false);
 }
 
-bool WebFrameImpl::IsLoading() const {
+bool WebFrameImpl::isLoading() const {
   if (!frame_)
     return false;
   return frame_->loader()->isLoading();
 }
 
-WebFrame* WebFrameImpl::GetOpener() const {
+WebFrame* WebFrameImpl::opener() const {
   if (frame_) {
     Frame* opener = frame_->loader()->opener();
     if (opener)
       return FromFrame(opener);
   }
   return NULL;
 }
 
-WebFrame* WebFrameImpl::GetParent() const {
+WebFrame* WebFrameImpl::parent() const {
   if (frame_) {
     Frame *parent = frame_->tree()->parent();
     if (parent)
       return FromFrame(parent);
   }
   return NULL;
 }
 
-WebFrame* WebFrameImpl::GetTop() const {
+WebFrame* WebFrameImpl::top() const {
   if (frame_)
     return FromFrame(frame_->tree()->top());
 
   return NULL;
 }
 
-WebFrame* WebFrameImpl::GetChildFrame(const std::wstring& xpath) const {
-  // 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]
-
-  if (xpath.empty())
-    return NULL;
-
-  std::wstring secondary;
-  String xpath_str;
-
-  std::wstring::size_type delim_pos = xpath.find_first_of(L'\n');
-  if (delim_pos != std::wstring::npos) {
-    std::wstring primary = xpath.substr(0, delim_pos);
-    secondary = xpath.substr(delim_pos + 1);
-    xpath_str = webkit_glue::StdWStringToString(primary);
-  } else {
-    xpath_str = webkit_glue::StdWStringToString(xpath);
-  }
-
-  Document* document = frame_->document();
-
-  ExceptionCode ec = 0;
-  PassRefPtr<XPathResult> xpath_result =
-    document->evaluate(xpath_str,
-    document,
-    NULL, /* namespace */
-    XPathResult::ORDERED_NODE_ITERATOR_TYPE,
-    NULL, /* XPathResult object */
-    ec);
-
-  if (!xpath_result.get())
-    return NULL;
-
-  Node* node = xpath_result->iterateNext(ec);
-
-  if (!node || !node->isFrameOwnerElement())
-    return NULL;
-  HTMLFrameOwnerElement* frame_element =
-    static_cast<HTMLFrameOwnerElement*>(node);
-  WebFrame* web_frame = FromFrame(frame_element->contentFrame());
-
-  if (secondary.empty())
-    return web_frame;
-  else
-    return web_frame->GetChildFrame(secondary);
-}
-
-void WebFrameImpl::SetInViewSourceMode(bool enable) {
+void WebFrameImpl::enableViewSourceMode(bool enable) {
   if (frame_)
     frame_->setInViewSourceMode(enable);
 }
 
-bool WebFrameImpl::GetInViewSourceMode() const {
+bool WebFrameImpl::isViewSourceModeEnabled() const {
   if (frame_)
     return frame_->inViewSourceMode();
 
   return false;
 }
 
-WebView* WebFrameImpl::GetView() const {
+WebView* WebFrameImpl::view() const {
   return GetWebViewImpl();
 }
 
-void WebFrameImpl::GetForms(std::vector<WebForm>* results) const {
-  results->clear();
+void WebFrameImpl::forms(WebVector<WebForm>& results) const {
   if (!frame_)
     return;
+
   RefPtr<WebCore::HTMLCollection> forms = frame_->document()->forms();
-  unsigned int form_count = forms->length();
-  for (unsigned int i = 0; i < form_count; ++i) {
+  size_t form_count = forms->length();
+
+  WebVector<WebForm> temp(form_count);
+  for (size_t i = 0; i < form_count; ++i) {
     Node* node = forms->item(i);
     // Strange but true, sometimes item can be NULL.
     if (node) {
-      results->push_back(webkit_glue::HTMLFormElementToWebForm(
-          static_cast<HTMLFormElement*>(node)));
+      temp[i] = webkit_glue::HTMLFormElementToWebForm(
+          static_cast<HTMLFormElement*>(node));
     }
   }
+  results.swap(temp);
 }
 
-std::string WebFrameImpl::GetSecurityOrigin() const {
+WebString WebFrameImpl::securityOrigin() const {
   if (frame_) {
     if (frame_->document())
-      return webkit_glue::StringToStdString(
+      return webkit_glue::StringToWebString(
           frame_->document()->securityOrigin()->toString());
   }
-  return "null";
+  return WebString::fromUTF8("null");
 }
 
-void WebFrameImpl::BindToWindowObject(const std::wstring& name,
+void WebFrameImpl::bindToWindowObject(const WebString& name,
                                       NPObject* object) {
-  assert(frame_);
+  DCHECK(frame_);
   if (!frame_ || !frame_->script()->isEnabled())
     return;
 
   // TODO(mbelshe): Move this to the ScriptController and make it JS neutral.
 
-  String key = webkit_glue::StdWStringToString(name);
+  String key = webkit_glue::WebStringToString(name);
 #if USE(V8)
   frame_->script()->bindToWindowObject(frame_, key, object);
 #endif
 
 #if USE(JSC)
   JSC::JSGlobalObject* window = frame_->script()->globalObject();
   JSC::ExecState* exec = window->globalExec();
   JSC::Bindings::RootObject* root = frame_->script()->bindingRootObject();
   ASSERT(exec);
   JSC::RuntimeObjectImp* instance(JSC::Bindings::Instance::createRuntimeObject(
       exec, JSC::Bindings::CInstance::create(object, root)));
   JSC::Identifier id(exec, key.latin1().data());
   JSC::PutPropertySlot slot;
   window->put(exec, id, instance, slot);
 #endif
 }
 
 
 // Call JavaScript garbage collection.
-void WebFrameImpl::CallJSGC() {
+void WebFrameImpl::collectGarbage() {
   if (!frame_)
     return;
   if (!frame_->settings()->isJavaScriptEnabled())
     return;
   // TODO(mbelshe): Move this to the ScriptController and make it JS neutral.
 #if USE(V8)
   frame_->script()->collectGarbage();
 #endif
 }
 
-void WebFrameImpl::GrantUniversalAccess() {
+void WebFrameImpl::grantUniversalAccess() {
   DCHECK(frame_ && frame_->document());
   if (frame_ && frame_->document()) {
     frame_->document()->securityOrigin()->grantUniversalAccess();
   }
 }
 
-void WebFrameImpl::GetContentAsPlainText(int max_chars,
-                                         std::wstring* text) const {
-  text->clear();
+WebString WebFrameImpl::contentAsText(size_t max_chars) const {
   if (!frame_)
-    return;
+    return WebString();
 
-  FrameContentAsPlainText(max_chars, frame_, text);
+  std::wstring text;
+  FrameContentAsPlainText(max_chars, frame_, &text);
+  // TODO(darin): Too many string copies!!!
+  return WideToUTF16Hack(text);
 }
 
-NPObject* WebFrameImpl::GetWindowNPObject() {
+NPObject* WebFrameImpl::windowObject() const {
   if (!frame_)
     return NULL;
 
   return frame_->script()->windowScriptNPObject();
 }
 
 #if USE(V8)
   // Returns the V8 context for this frame, or an empty handle if there is
   // none.
-v8::Local<v8::Context> WebFrameImpl::GetMainWorldScriptContext() {
+v8::Local<v8::Context> WebFrameImpl::mainWorldScriptContext() const {
   if (!frame_)
     return v8::Local<v8::Context>();
 
   return WebCore::V8Proxy::mainWorldContext(frame_);
 }
 #endif
 
 void WebFrameImpl::InvalidateArea(AreaToInvalidate area) {
   ASSERT(frame() && frame()->view());
   FrameView* view = frame()->view();
@@ skipping 11 matching lines @@
       // Invalidate the vertical scroll bar region for the view.
       IntRect scroll_bar_vert(
           view->x() + view->visibleWidth(), view->y(),
           WebCore::ScrollbarTheme::nativeTheme()->scrollbarThickness(),
           view->visibleHeight());
       view->invalidateRect(scroll_bar_vert);
     }
   }
 }
 
-void WebFrameImpl::IncreaseMatchCount(int count, int request_id) {
+void WebFrameImpl::increaseMatchCount(int count, int request_id) {
   // This function should only be called on the mainframe.
-  DCHECK(this == static_cast<WebFrameImpl*>(GetView()->GetMainFrame()));
+  DCHECK(!parent());
 
   total_matchcount_ += count;
 
   // Update the UI with the latest findings.
-  WebViewDelegate* webview_delegate = GetView()->GetDelegate();
+  WebViewDelegate* webview_delegate = GetWebViewImpl()->GetDelegate();
   DCHECK(webview_delegate);
   if (webview_delegate)
     webview_delegate->ReportFindInPageMatchCount(total_matchcount_, request_id,
                                                  frames_scoping_count_ == 0);
 }
 
-void WebFrameImpl::ReportFindInPageSelection(const WebRect& selection_rect,
+void WebFrameImpl::reportFindInPageSelection(const WebRect& selection_rect,
                                              int active_match_ordinal,
                                              int request_id) {
   // Update the UI with the latest selection rect.
-  WebViewDelegate* webview_delegate = GetView()->GetDelegate();
+  WebViewDelegate* webview_delegate = GetWebViewImpl()->GetDelegate();
   DCHECK(webview_delegate);
   if (webview_delegate) {
     webview_delegate->ReportFindInPageSelection(
         request_id,
         OrdinalOfFirstMatchForFrame(this) + active_match_ordinal,
         selection_rect);
   }
 }
 
-void WebFrameImpl::ResetMatchCount() {
+void WebFrameImpl::resetMatchCount() {
   total_matchcount_ = 0;
   frames_scoping_count_ = 0;
 }
 
-bool WebFrameImpl::Find(int request_id,
-                        const string16& search_text,
+bool WebFrameImpl::find(int request_id,
+                        const WebString& search_text,
                         const WebFindOptions& options,
                         bool wrap_within_frame,
                         WebRect* selection_rect) {
-  WebCore::String webcore_string = webkit_glue::String16ToString(search_text);
+  WebCore::String webcore_string = webkit_glue::WebStringToString(search_text);
 
-  WebFrameImpl* const main_frame_impl =
-      static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
+  WebFrameImpl* const main_frame_impl = GetWebViewImpl()->main_frame();
 
   if (!options.findNext)
     frame()->page()->unmarkAllTextMatches();
   else
     SetMarkerActive(active_match_.get(), false);  // Active match is changing.
 
   // Starts the search from the current selection.
   bool start_in_selection = true;
 
   // If the user has selected something since the last Find operation we want
@@ skipping 25 matching lines @@
     // be active but we still continue searching. This matches Safari's
     // behavior, including some oddities when selectable and un-selectable text
     // are mixed on a page: see https://bugs.webkit.org/show_bug.cgi?id=19127.
     if (new_selection.isNone() ||
         (new_selection.start() == new_selection.end())) {
       active_match_ = NULL;
     } else {
       active_match_ = new_selection.toNormalizedRange();
       curr_selection_rect = active_match_->boundingBox();
       SetMarkerActive(active_match_.get(), true);  // Active.
-      ClearSelection();  // WebKit draws the highlighting for all matches.
+      clearSelection();  // WebKit draws the highlighting for all matches.
     }
 
     if (!options.findNext) {
       // This is a Find operation, so we set the flag to ask the scoping effort
       // to find the active rect for us so we can update the ordinal (n of m).
       locating_active_rect_ = true;
     } else {
       if (old_active_frame != this) {
         // If the active frame has changed it means that we have a multi-frame
         // page and we just switch to searching in a new frame. Then we just
@@ skipping 11 matching lines @@
         if (active_match_index_ + 1 == 0)
           active_match_index_ = last_match_count_ - 1;
       }
       if (selection_rect) {
         WebRect rect = webkit_glue::IntRectToWebRect(
             frame()->view()->convertToContainingWindow(curr_selection_rect));
         rect.x -= frameview()->scrollOffset().width();
         rect.y -= frameview()->scrollOffset().height();
         *selection_rect = rect;
 
-        ReportFindInPageSelection(rect,
+        reportFindInPageSelection(rect,
                                   active_match_index_ + 1,
                                   request_id);
       }
     }
   } else {
     // Nothing was found in this frame.
     active_match_ = NULL;
 
     // Erase all previous tickmarks and highlighting.
     InvalidateArea(INVALIDATE_ALL);
   }
 
   return found;
 }
 
 int WebFrameImpl::OrdinalOfFirstMatchForFrame(WebFrameImpl* frame) const {
   int ordinal = 0;
   WebViewImpl* web_view = GetWebViewImpl();
-  WebFrameImpl* const main_frame_impl =
-    static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
+  WebFrameImpl* const main_frame_impl = GetWebViewImpl()->main_frame();
   // Iterate from the main frame up to (but not including) |frame| and
   // add up the number of matches found so far.
   for (WebFrameImpl* it = main_frame_impl;
        it != frame;
        it = static_cast<WebFrameImpl*>(
            web_view->GetNextFrameAfter(it, true))) {
     if (it->last_match_count_ > 0)
       ordinal += it->last_match_count_;
   }
 
   return ordinal;
 }
 
 bool WebFrameImpl::ShouldScopeMatches(const string16& search_text) {
   // Don't scope if we can't find a frame or if the frame is not visible.
   // The user may have closed the tab/application, so abort.
-  if (!frame() || !Visible())
+  if (!frame() || !hasVisibleContent())
     return false;
 
   DCHECK(frame()->document() && frame()->view());
 
   // If the frame completed the scoping operation and found 0 matches the last
   // time it was searched, then we don't have to search it again if the user is
   // just adding to the search string or sending the same search string again.
   if (scoping_complete_ &&
       !last_search_string_.empty() && last_match_count_ == 0) {
     // Check to see if the search string prefixes match.
@@ skipping 60 matching lines @@
   }
 }
 
 void WebFrameImpl::SetMarkerActive(WebCore::Range* range, bool active) {
   if (!range)
     return;
 
   frame()->document()->setMarkersActive(range, active);
 }
 
-void WebFrameImpl::ScopeStringMatches(int request_id,
-                                      const string16& search_text,
+void WebFrameImpl::scopeStringMatches(int request_id,
+                                      const WebString& search_text,
                                       const WebFindOptions& options,
                                       bool reset) {
   if (!ShouldScopeMatches(search_text))
     return;
 
-  WebFrameImpl* main_frame_impl =
-      static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
+  WebFrameImpl* main_frame_impl = GetWebViewImpl()->main_frame();
 
   if (reset) {
     // This is a brand new search, so we need to reset everything.
     // Scoping is just about to begin.
     scoping_complete_ = false;
     // Clear highlighting for this frame.
     if (frame()->markedTextMatchesAreHighlighted())
       frame()->page()->unmarkAllTextMatches();
     // Clear the counters from last operation.
     last_match_count_ = 0;
     next_invalidate_after_ = 0;
 
     resume_scoping_from_range_ = NULL;
 
     main_frame_impl->frames_scoping_count_++;
 
     // Now, defer scoping until later to allow find operation to finish quickly.
     MessageLoop::current()->PostTask(FROM_HERE,
         scope_matches_factory_.NewRunnableMethod(
-            &WebFrameImpl::ScopeStringMatches,
+            &WebFrameImpl::scopeStringMatches,
             request_id,
             search_text,
             options,
             false));  // false=we just reset, so don't do it again.
     return;
   }
 
   WebCore::String webcore_string = webkit_glue::String16ToString(search_text);
 
   RefPtr<Range> search_range(rangeOfContents(frame()->document()));
@@ skipping 80 matching lines @@
         main_frame_impl->active_match_frame_ = this;
         found_active_match = true;
         // We also know which tickmark is active now.
         active_match_index_ = match_count - 1;
         // To stop looking for the active tickmark, we set this flag.
         locating_active_rect_ = false;
 
         // Notify browser of new location for the selected rectangle.
         result_bounds.move(-frameview()->scrollOffset().width(),
                            -frameview()->scrollOffset().height());
-        ReportFindInPageSelection(
+        reportFindInPageSelection(
             webkit_glue::IntRectToWebRect(
                 frame()->view()->convertToContainingWindow(result_bounds)),
             active_match_index_ + 1,
             request_id);
       }
 
       AddMarker(result_range.get(), found_active_match);
     }
 
     resume_scoping_from_range_ = result_range;
     timeout = (Time::Now() - start_time).InMilliseconds() >= kTimeout;
   } while (!timeout);
 
   // Remember what we search for last time, so we can skip searching if more
   // letters are added to the search string (and last outcome was 0).
   last_search_string_ = search_text;
 
   if (match_count > 0) {
     frame()->setMarkedTextMatchesAreHighlighted(true);
 
     last_match_count_ += match_count;
 
     // Let the mainframe know how much we found during this pass.
-    main_frame_impl->IncreaseMatchCount(match_count, request_id);
+    main_frame_impl->increaseMatchCount(match_count, request_id);
   }
 
   if (timeout) {
     // If we found anything during this pass, we should redraw. However, we
     // don't want to spam too much if the page is extremely long, so if we
     // reach a certain point we start throttling the redraw requests.
     if (match_count > 0)
       InvalidateIfNecessary();
 
     // Scoping effort ran out of time, lets ask for another time-slice.
     MessageLoop::current()->PostTask(FROM_HERE,
         scope_matches_factory_.NewRunnableMethod(
-            &WebFrameImpl::ScopeStringMatches,
+            &WebFrameImpl::scopeStringMatches,
             request_id,
             search_text,
             options,
             false));  // don't reset.
 
     return;  // Done for now, resume work later.
   }
 
   // This frame has no further scoping left, so it is done. Other frames might,
   // of course, continue to scope matches.
   scoping_complete_ = true;
   main_frame_impl->frames_scoping_count_--;
 
   // If this is the last frame to finish scoping we need to trigger the final
   // update to be sent.
   if (main_frame_impl->frames_scoping_count_ == 0)
-    main_frame_impl->IncreaseMatchCount(0, request_id);
+    main_frame_impl->increaseMatchCount(0, request_id);
 
   // This frame is done, so show any scrollbar tickmarks we haven't drawn yet.
   InvalidateArea(INVALIDATE_SCROLLBAR);
 }
 
-void WebFrameImpl::CancelPendingScopingEffort() {
+void WebFrameImpl::cancelPendingScopingEffort() {
   scope_matches_factory_.RevokeAll();
   active_match_index_ = -1;
 }
 
 void WebFrameImpl::SetFindEndstateFocusAndSelection() {
-  WebFrameImpl* main_frame_impl =
-      static_cast<WebFrameImpl*>(GetView()->GetMainFrame());
+  WebFrameImpl* main_frame_impl = GetWebViewImpl()->main_frame();
 
   if (this == main_frame_impl->active_match_frame() &&
       active_match_.get()) {
     // If the user has set the selection since the match was found, we
     // don't focus anything.
     VisibleSelection selection(frame()->selection()->selection());
     if (!selection.isNone())
       return;
 
     // Try to find the first focusable node up the chain, which will, for
@@ skipping 14 matching lines @@
         if (node->isFocusable()) {
           frame()->document()->setFocusedNode(node);
           break;
         }
         node = node->traverseNextNode();
       }
     }
   }
 }
 
-void WebFrameImpl::StopFinding(bool clear_selection) {
+void WebFrameImpl::stopFinding(bool clear_selection) {
   if (!clear_selection)
     SetFindEndstateFocusAndSelection();
-  CancelPendingScopingEffort();
+  cancelPendingScopingEffort();
 
   // Remove all markers for matches found and turn off the highlighting.
-  if (this == static_cast<WebFrameImpl*>(GetView()->GetMainFrame()))
+  if (!parent())
     frame()->document()->removeMarkers(WebCore::DocumentMarker::TextMatch);
   frame()->setMarkedTextMatchesAreHighlighted(false);
 
   // Let the frame know that we don't want tickmarks or highlighting anymore.
   InvalidateArea(INVALIDATE_ALL);
 }
 
-void WebFrameImpl::SelectAll() {
+void WebFrameImpl::selectAll() {
   frame()->selection()->selectAll();
 
-  WebViewDelegate* d = GetView()->GetDelegate();
+  WebViewDelegate* d = GetWebViewImpl()->GetDelegate();
   if (d)
     d->UserMetricsRecordAction(L"SelectAll");
 }
 
-void WebFrameImpl::Copy() {
-  frame()->editor()->copy();
-
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"Copy");
+WebRange WebFrameImpl::selectionRange() const {
+  return webkit_glue::RangeToWebRange(
+      frame()->selection()->toNormalizedRange());
 }
 
-void WebFrameImpl::Cut() {
-  frame()->editor()->cut();
+WebString WebFrameImpl::selectionAsText() const {
+  RefPtr<Range> range = frame()->selection()->toNormalizedRange();
+  if (!range.get())
+    return WebString();
 
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"Cut");
+  String text = range->text();
+#if defined(OS_WIN)
+  WebCore::replaceNewlinesWithWindowsStyleNewlines(text);
+#endif
+  WebCore::replaceNBSPWithSpace(text);
+  return webkit_glue::StringToWebString(text);
 }
 
-void WebFrameImpl::Paste() {
-  frame()->editor()->paste();
+WebString WebFrameImpl::selectionAsMarkup() const {
+  RefPtr<Range> range = frame()->selection()->toNormalizedRange();
+  if (!range.get())
+    return WebString();
 
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"Paste");
+  String markup = WebCore::createMarkup(range.get(), 0);
+  return webkit_glue::StringToWebString(markup);
 }
 
-void WebFrameImpl::Replace(const std::wstring& wtext) {
-  String text = webkit_glue::StdWStringToString(wtext);
+void WebFrameImpl::replaceSelection(const WebString& wtext) {
+  String text = webkit_glue::WebStringToString(wtext);
   RefPtr<DocumentFragment> fragment = createFragmentFromText(
       frame()->selection()->toNormalizedRange().get(), text);
   WebCore::applyCommand(WebCore::ReplaceSelectionCommand::create(
       frame()->document(), fragment.get(), false, true, true));
 }
 
-void WebFrameImpl::ToggleSpellCheck() {
+void WebFrameImpl::insertText(const WebString& text) {
+  frame()->editor()->insertText(webkit_glue::WebStringToString(text), NULL);
+}
+
+void WebFrameImpl::setMarkedText(
+    const WebString& text, unsigned location, unsigned length) {
+  WebCore::Editor* editor = frame()->editor();
+  WebCore::String str = webkit_glue::WebStringToString(text);
+
+  editor->confirmComposition(str);
+
+  WTF::Vector<WebCore::CompositionUnderline> decorations;
+  editor->setComposition(str, decorations, location, length);
+}
+
+void WebFrameImpl::unmarkText() {
+  frame()->editor()->confirmCompositionWithoutDisturbingSelection();
+}
+
+bool WebFrameImpl::hasMarkedText() const {
+  return frame()->editor()->hasComposition();
+}
+
+WebRange WebFrameImpl::markedRange() const {
+  return webkit_glue::RangeToWebRange(frame()->editor()->compositionRange());
+}
+
+void WebFrameImpl::enableContinuousSpellChecking(bool enable) {
+  if (enable == isContinuousSpellCheckingEnabled())
+    return;
   frame()->editor()->toggleContinuousSpellChecking();
 }
 
-bool WebFrameImpl::SpellCheckEnabled() {
+bool WebFrameImpl::isContinuousSpellCheckingEnabled() const {
   return frame()->editor()->isContinuousSpellCheckingEnabled();
 }
 
-void WebFrameImpl::Delete() {
-  frame()->editor()->command("Delete").execute();
-
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"DeleteSelection");
-}
-
-void WebFrameImpl::Undo() {
-  frame()->editor()->undo();
-
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"Undo");
-}
-
-void WebFrameImpl::Redo() {
-  frame()->editor()->redo();
-
-  WebViewDelegate* d = GetView()->GetDelegate();
-  if (d)
-    d->UserMetricsRecordAction(L"Redo");
-}
-
-void WebFrameImpl::ClearSelection() {
+void WebFrameImpl::clearSelection() {
   frame()->selection()->clear();
 }
 
-bool WebFrameImpl::HasSelection() {
+bool WebFrameImpl::hasSelection() const {
   // frame()->selection()->isNone() never returns true.
-  return (frame()->selection()->start() !=
-      frame()->selection()->end());
+  return (frame()->selection()->start() != frame()->selection()->end());
 }
 
-std::string WebFrameImpl::GetSelection(bool as_html) {
-  RefPtr<Range> range = frame()->selection()->toNormalizedRange();
-  if (!range.get())
-    return std::string();
-
-  if (as_html) {
-    String markup = WebCore::createMarkup(range.get(), 0);
-    return webkit_glue::StringToStdString(markup);
-  } else {
-    String text = range->text();
-#if defined(OS_WIN)
-    WebCore::replaceNewlinesWithWindowsStyleNewlines(text);
-#endif
-    WebCore::replaceNBSPWithSpace(text);
-    return webkit_glue::StringToStdString(text);
-  }
-}
-
-std::string WebFrameImpl::GetFullPageHtml() {
-  return webkit_glue::StringToStdString(createFullMarkup(frame_->document()));
+WebString WebFrameImpl::contentAsMarkup() const {
+  return webkit_glue::StringToWebString(createFullMarkup(frame_->document()));
 }
 
 void WebFrameImpl::CreateFrameView() {
   ASSERT(frame_);  // If frame_ doesn't exist, we probably didn't init properly.
 
   WebCore::Page* page = frame_->page();
   DCHECK(page);
 
   DCHECK(page->mainFrame() != NULL);
 
@@ skipping 101 matching lines @@
     const WebURLError& web_error =
         webkit_glue::ResourceErrorToWebURLError(error);
     if (was_provisional) {
       delegate->DidFailProvisionalLoadWithError(web_view, web_error, this);
     } else {
       delegate->DidFailLoadWithError(web_view, web_error, this);
     }
   }
 }
 
-void WebFrameImpl::DispatchWillSendRequest(WebURLRequest* request) {
+void WebFrameImpl::dispatchWillSendRequest(WebURLRequest& request) {
   ResourceResponse response;
   frame_->loader()->client()->dispatchWillSendRequest(NULL, 0,
-      *webkit_glue::WebURLRequestToMutableResourceRequest(request),
+      *webkit_glue::WebURLRequestToMutableResourceRequest(&request),
       response);
 }
 
-void WebFrameImpl::CommitDocumentData(const char* data, size_t data_len) {
+void WebFrameImpl::commitDocumentData(const char* data, size_t data_len) {
   DocumentLoader* document_loader = frame_->loader()->documentLoader();
 
   // Set the text encoding.  This calls begin() for us.  It is safe to call
   // this multiple times (Mac does: page/mac/WebCoreFrameBridge.mm).
   bool user_chosen = true;
   String encoding = document_loader->overrideEncoding();
   if (encoding.isNull()) {
     user_chosen = false;
     encoding = document_loader->response().textEncodingName();
   }
   frame_->loader()->setEncoding(encoding, user_chosen);
 
   // NOTE: mac only does this if there is a document
   frame_->loader()->addData(data, data_len);
 }
 
-void WebFrameImpl::ExecuteScript(const WebScriptSource& source) {
+void WebFrameImpl::executeScript(const WebScriptSource& source) {
   frame_->loader()->executeScript(
       WebCore::ScriptSourceCode(
           webkit_glue::WebStringToString(source.code),
           webkit_glue::WebURLToKURL(source.url),
           source.startLine));
 }
 
-bool WebFrameImpl::InsertCSSStyles(const std::string& css) {
+bool WebFrameImpl::insertStyleText(const WebString& css) {
   Document* document = frame()->document();
   if (!document)
     return false;
   WebCore::Element* document_element = document->documentElement();
   if (!document_element)
     return false;
 
   RefPtr<WebCore::Element> stylesheet = document->createElement(
       WebCore::HTMLNames::styleTag, false);
   ExceptionCode err = 0;
-  stylesheet->setTextContent(webkit_glue::StdStringToString(css), err);
+  stylesheet->setTextContent(webkit_glue::WebStringToString(css), err);
   DCHECK(!err) << "Failed to set style element content";
   WebCore::Node* first = document_element->firstChild();
   bool success = document_element->insertBefore(stylesheet, first, err);
   DCHECK(success) << "Failed to insert stylesheet";
   return success;
 }
 
-void WebFrameImpl::ExecuteScriptInNewContext(
-    const WebScriptSource* sources_in, int num_sources,
-      int extension_group) {
+void WebFrameImpl::executeScriptInNewContext(
+    const WebScriptSource* sources_in, unsigned num_sources,
+    int extension_group) {
   Vector<WebCore::ScriptSourceCode> sources;
 
-  for (int i = 0; i < num_sources; ++i) {
+  for (unsigned i = 0; i < num_sources; ++i) {
     sources.append(WebCore::ScriptSourceCode(
         webkit_glue::WebStringToString(sources_in[i].code),
         webkit_glue::WebURLToKURL(sources_in[i].url),
         sources_in[i].startLine));
   }
 
   frame_->script()->evaluateInNewContext(sources, extension_group);
 }
 
-void WebFrameImpl::ExecuteScriptInNewWorld(
-    const WebScriptSource* sources_in, int num_sources,
-      int extension_group) {
+void WebFrameImpl::executeScriptInNewWorld(
+    const WebScriptSource* sources_in, unsigned num_sources,
+    int extension_group) {
   Vector<WebCore::ScriptSourceCode> sources;
 
-  for (int i = 0; i < num_sources; ++i) {
+  for (unsigned i = 0; i < num_sources; ++i) {
     sources.append(WebCore::ScriptSourceCode(
         webkit_glue::WebStringToString(sources_in[i].code),
         webkit_glue::WebURLToKURL(sources_in[i].url),
         sources_in[i].startLine));
   }
 
   frame_->script()->evaluateInNewWorld(sources, extension_group);
 }
 
-std::wstring WebFrameImpl::GetName() {
-  return webkit_glue::StringToStdWString(frame_->tree()->name());
+WebString WebFrameImpl::name() const {
+  return webkit_glue::StringToWebString(frame_->tree()->name());
 }
 
-WebTextInput* WebFrameImpl::GetTextInput() {
-  if (!webtextinput_impl_.get()) {
-    webtextinput_impl_.reset(new WebTextInputImpl(this));
-  }
-  return webtextinput_impl_.get();
-}
-
-bool WebFrameImpl::Visible() {
+bool WebFrameImpl::hasVisibleContent() const {
   return frame()->view()->visibleWidth() > 0 &&
          frame()->view()->visibleHeight() > 0;
 }
 
 PassRefPtr<Frame> WebFrameImpl::CreateChildFrame(
     const FrameLoadRequest& request, HTMLFrameOwnerElement* owner_element) {
   // TODO(darin): share code with initWithName()
 
   scoped_refptr<WebFrameImpl> webframe = new WebFrameImpl();
 
@@ skipping 30 matching lines @@
 
   // A synchronous navigation (about:blank) would have already processed
   // onload, so it is possible for the frame to have already been destroyed by
   // script in the page.
   if (!child_frame->tree()->parent())
     return NULL;
 
   return child_frame.release();
 }
 
-bool WebFrameImpl::ExecuteEditCommandByName(const std::string& name,
-                                            const std::string& value) {
+bool WebFrameImpl::executeCommand(const WebString& name) {
   ASSERT(frame());
-  return frame()->editor()->command(webkit_glue::StdStringToString(name))
-      .execute(webkit_glue::StdStringToString(value));
+
+  if (name.length() <= 2)
+    return false;
+
+  // Since we don't have NSControl, we will convert the format of command
+  // string and call the function on Editor directly.
+  string16 command = name;
+
+  // Make sure the first letter is upper case.
+  command.replace(0, 1, 1, toupper(command.at(0)));
+
+  // Remove the trailing ':' if existing.
+  if (command.at(command.length() - 1) == ':')
+    command.erase(command.length() - 1, 1);
+
+  bool rv = true;
+
+  // Specially handling commands that Editor::execCommand does not directly
+  // support.
+  if (EqualsASCII(command, "DeleteToEndOfParagraph")) {
+    WebCore::Editor* editor = frame()->editor();
+    if (!editor->deleteWithDirection(WebCore::SelectionController::FORWARD,
+                                     WebCore::ParagraphBoundary,
+                                     true,
+                                     false)) {
+      editor->deleteWithDirection(WebCore::SelectionController::FORWARD,
+                                  WebCore::CharacterGranularity,
+                                  true,
+                                  false);
+    }
+  } else if (EqualsASCII(command, "Indent")) {
+    frame()->editor()->indent();
+  } else if (EqualsASCII(command, "Outdent")) {
+    frame()->editor()->outdent();
+  } else if (EqualsASCII(command, "DeleteBackward")) {
+    rv = frame()->editor()->command(AtomicString("BackwardDelete")).execute();
+  } else if (EqualsASCII(command, "DeleteForward")) {
+    rv = frame()->editor()->command(AtomicString("ForwardDelete")).execute();
+  } else {
+    rv = frame()->editor()->command(AtomicString(command.c_str())).execute();
+  }
+  return rv;
 }
 
-bool WebFrameImpl::IsEditCommandEnabled(const std::string& name) {
+bool WebFrameImpl::executeCommand(const WebString& name,
+                                  const WebString& value) {
   ASSERT(frame());
-  return frame()->editor()->command(webkit_glue::StdStringToString(name))
-      .isEnabled();
+  return frame()->editor()->command(webkit_glue::WebStringToString(name)).
+      execute(webkit_glue::WebStringToString(value));
 }
 
-void WebFrameImpl::AddMessageToConsole(const WebConsoleMessage& message) {
+bool WebFrameImpl::isCommandEnabled(const WebString& name) const {
+  ASSERT(frame());
+  return frame()->editor()->command(webkit_glue::WebStringToString(name)).
+      isEnabled();
+}
+
+void WebFrameImpl::addMessageToConsole(const WebConsoleMessage& message) {
   ASSERT(frame());
 
   WebCore::MessageLevel webcore_message_level;
   switch (message.level) {
     case WebConsoleMessage::LevelTip:
       webcore_message_level = WebCore::TipMessageLevel;
       break;
     case WebConsoleMessage::LevelLog:
       webcore_message_level = WebCore::LogMessageLevel;
       break;
     case WebConsoleMessage::LevelWarning:
       webcore_message_level = WebCore::WarningMessageLevel;
       break;
     case WebConsoleMessage::LevelError:
       webcore_message_level = WebCore::ErrorMessageLevel;
       break;
     default:
       NOTREACHED();
       return;
   }
 
   frame()->domWindow()->console()->addMessage(
       WebCore::OtherMessageSource, WebCore::LogMessageType,
       webcore_message_level, webkit_glue::WebStringToString(message.text),
       1, String());
 }
 
-WebSize WebFrameImpl::ScrollOffset() const {
+WebSize WebFrameImpl::scrollOffset() const {
   WebCore::FrameView* view = frameview();
   if (view)
     return webkit_glue::IntSizeToWebSize(view->scrollOffset());
 
   return WebSize();
 }
 
+WebSize WebFrameImpl::contentsSize() const {
+  return webkit_glue::IntSizeToWebSize(frame()->view()->contentsSize());
+}
+
+WebFrame* WebFrameImpl::firstChild() const {
+  return FromFrame(frame()->tree()->firstChild());
+}
+
+WebFrame* WebFrameImpl::lastChild() const {
+  return FromFrame(frame()->tree()->lastChild());
+}
+
+WebFrame* WebFrameImpl::nextSibling() const {
+  return FromFrame(frame()->tree()->nextSibling());
+}
+
+WebFrame* WebFrameImpl::previousSibling() const {
+  return FromFrame(frame()->tree()->previousSibling());
+}
+
+WebFrame* WebFrameImpl::traverseNext(bool wrap) const {
+  return FromFrame(frame()->tree()->traverseNextWithWrap(wrap));
+}
+
+WebFrame* WebFrameImpl::traversePrevious(bool wrap) const {
+  return FromFrame(frame()->tree()->traversePreviousWithWrap(wrap));
+}
+
+WebFrame* WebFrameImpl::findChildByName(const WebKit::WebString& name) const {
+  return FromFrame(frame()->tree()->child(
+      webkit_glue::WebStringToString(name)));
+}
+
+WebFrame* WebFrameImpl::findChildByExpression(
+    const WebKit::WebString& xpath) const {
+  if (xpath.isEmpty())
+    return NULL;
+
+  Document* document = frame_->document();
+
+  ExceptionCode ec = 0;
+  PassRefPtr<XPathResult> xpath_result =
+      document->evaluate(webkit_glue::WebStringToString(xpath),
+      document,
+      NULL, /* namespace */
+      XPathResult::ORDERED_NODE_ITERATOR_TYPE,
+      NULL, /* XPathResult object */
+      ec);
+  if (!xpath_result.get())
+    return NULL;
+
+  Node* node = xpath_result->iterateNext(ec);
+
+  if (!node || !node->isFrameOwnerElement())
+    return NULL;
+  HTMLFrameOwnerElement* frame_element =
+    static_cast<HTMLFrameOwnerElement*>(node);
+  return FromFrame(frame_element->contentFrame());
+}
+
 void WebFrameImpl::SetAllowsScrolling(bool flag) {
   frame_->view()->setCanHaveScrollbars(flag);
 }
 
-int WebFrameImpl::PrintBegin(const WebSize& page_size) {
+int WebFrameImpl::printBegin(const WebSize& page_size) {
   DCHECK_EQ(frame()->document()->isFrameSet(), false);
 
   print_context_.reset(new ChromePrintContext(frame()));
   WebCore::FloatRect rect(0, 0,
                           static_cast<float>(page_size.width),
                           static_cast<float>(page_size.height));
   print_context_->begin(rect.width());
   float page_height;
   // We ignore the overlays calculation for now since they are generated in the
   // browser. page_height is actually an output parameter.
   print_context_->computePageRects(rect, 0, 0, 1.0, page_height);
   return print_context_->pageCount();
 }
 
-float WebFrameImpl::PrintPage(int page, WebCanvas* canvas) {
+float WebFrameImpl::printPage(int page, WebCanvas* canvas) {
   // Ensure correct state.
   if (!print_context_.get() || page < 0 || !frame() || !frame()->document()) {
     NOTREACHED();
     return 0;
   }
 
 #if defined(OS_WIN) || defined(OS_LINUX)
   PlatformContextSkia context(canvas);
   GraphicsContext spool(&context);
 #elif defined(OS_MACOSX)
   CGContextRef context = canvas->beginPlatformPaint();
   GraphicsContext spool(context);
   WebCore::LocalCurrentGraphicsContext localContext(&spool);
 #endif
 
   return print_context_->spoolPage(spool, page);
 }
 
-void WebFrameImpl::PrintEnd() {
+void WebFrameImpl::printEnd() {
   DCHECK(print_context_.get());
   if (print_context_.get())
     print_context_->end();
   print_context_.reset(NULL);
 }
 
-int WebFrameImpl::PendingFrameUnloadEventCount() const {
+unsigned WebFrameImpl::unloadListenerCount() const {
   return frame()->domWindow()->pendingUnloadEventListeners();
 }
 
 void WebFrameImpl::RegisterPasswordListener(
     PassRefPtr<WebCore::HTMLInputElement> input_element,
     webkit_glue::PasswordAutocompleteListener* listener) {
   RefPtr<WebCore::HTMLInputElement> element = input_element;
   DCHECK(password_listeners_.find(element) == password_listeners_.end());
   password_listeners_.set(element, listener);
 }
@@ skipping 32 matching lines @@
 
   SecurityOrigin* security_origin = frame_->document()->securityOrigin();
 
   if (!frame_->loader()->isScheduledLocationChangePending()) {
     frame_->loader()->stopAllLoaders();
     frame_->loader()->begin(frame_->loader()->url(), true, security_origin);
     frame_->loader()->write(script_result);
     frame_->loader()->end();
   }
 }