Replace WebDocument::focusedNode to focusedElement

content/renderer/render_view_impl.cc

 // Copyright (c) 2012 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 "content/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 1542 matching lines @@
 
   target_url_status_ = TARGET_NONE;
 }
 
 void RenderViewImpl::OnCopy() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   WebNode current_node = context_menu_node_.isNull() ?
-      GetFocusedNode() : context_menu_node_;
+      GetFocusedElement() : context_menu_node_;
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Copy"),
                                             current_node);
 }
 
 void RenderViewImpl::OnCut() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Cut"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 void RenderViewImpl::OnDelete() {
   if (!webview())
     return;
 
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Delete"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 void RenderViewImpl::OnExecuteEditCommand(const std::string& name,
     const std::string& value) {
   if (!webview() || !webview()->focusedFrame())
     return;
 
   webview()->focusedFrame()->executeCommand(
       WebString::fromUTF8(name), WebString::fromUTF8(value));
 }
 
 void RenderViewImpl::OnMoveCaret(const gfx::Point& point) {
   if (!webview())
     return;
 
   Send(new ViewHostMsg_MoveCaret_ACK(routing_id_));
 
   webview()->focusedFrame()->moveCaretSelection(point);
 }
 
 void RenderViewImpl::OnPaste() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Paste"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 void RenderViewImpl::OnPasteAndMatchStyle() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->executeCommand(
-      WebString::fromUTF8("PasteAndMatchStyle"), GetFocusedNode());
+      WebString::fromUTF8("PasteAndMatchStyle"), GetFocusedElement());
 }
 
 void RenderViewImpl::OnRedo() {
   if (!webview())
     return;
 
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Redo"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 void RenderViewImpl::OnReplace(const base::string16& text) {
   if (!webview())
     return;
 
   WebFrame* frame = webview()->focusedFrame();
   if (!frame->hasSelection())
     frame->selectWordAroundCaret();
 
   frame->replaceSelection(text);
 }
 
 void RenderViewImpl::OnReplaceMisspelling(const base::string16& text) {
   if (!webview())
     return;
 
   WebFrame* frame = webview()->focusedFrame();
   if (!frame->hasSelection())
     return;
 
   frame->replaceMisspelledRange(text);
 }
 
 void RenderViewImpl::OnScrollFocusedEditableNodeIntoRect(
     const gfx::Rect& rect) {
-  blink::WebNode node = GetFocusedNode();
-  if (!node.isNull()) {
-    if (IsEditableNode(node)) {
+  blink::WebElement element = GetFocusedElement();
+  if (!element.isNull()) {
+    if (IsEditableNode(element)) {
       webview()->saveScrollAndScaleState();
       webview()->scrollFocusedNodeIntoRect(rect);
     }
   }
 }
 
 void RenderViewImpl::OnSelectAll() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->executeCommand(
-      WebString::fromUTF8("SelectAll"), GetFocusedNode());
+      WebString::fromUTF8("SelectAll"), GetFocusedElement());
 }
 
 void RenderViewImpl::OnSelectRange(const gfx::Point& start,
                                    const gfx::Point& end) {
   if (!webview())
     return;
 
   Send(new ViewHostMsg_SelectRange_ACK(routing_id_));
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->selectRange(start, end);
 }
 
 void RenderViewImpl::OnSetEditCommandsForNextKeyEvent(
     const EditCommands& edit_commands) {
   edit_commands_ = edit_commands;
 }
 
 void RenderViewImpl::OnUndo() {
   if (!webview())
     return;
 
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Undo"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 void RenderViewImpl::OnUnselect() {
   if (!webview())
     return;
 
   base::AutoReset<bool> handling_select_range(&handling_select_range_, true);
   webview()->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"),
-                                            GetFocusedNode());
+                                            GetFocusedElement());
 }
 
 #if defined(OS_MACOSX)
 void RenderViewImpl::OnCopyToFindPboard() {
   if (!webview())
     return;
 
   // Since the find pasteboard supports only plain text, this can be simpler
   // than the |OnCopy()| case.
   WebFrame* frame = webview()->focusedFrame();
@@ skipping 69 matching lines @@
     return;
   if (in_live_resize)
     webview()->willStartLiveResize();
   else
     webview()->willEndLiveResize();
 }
 #endif
 
 #if defined(OS_ANDROID)
 void RenderViewImpl::OnUndoScrollFocusedEditableNodeIntoRect() {
-  const WebNode node = GetFocusedNode();
-  if (!node.isNull() && IsEditableNode(node))
+  const WebElement element = GetFocusedElement();
+  if (!element.isNull() && IsEditableNode(element))
     webview()->restoreScrollAndScaleState();
 }
 
 void RenderViewImpl::OnPauseVideo() {
   // Inform RendererMediaPlayerManager to release all video player resources.
   // If something is in progress the resource will not be freed, it will
   // only be freed once the tab is destroyed or if the user navigates away
   // via WebMediaPlayerAndroid::Destroy.
   media_player_manager_->ReleaseVideoResources();
 }
@@ skipping 473 matching lines @@
   EditCommands::iterator it = edit_commands_.begin();
   EditCommands::iterator end = edit_commands_.end();
 
   bool did_execute_command = false;
   for (; it != end; ++it) {
     // In gtk and cocoa, it's possible to bind multiple edit commands to one
     // key (but it's the exception). Once one edit command is not executed, it
     // seems safest to not execute the rest.
     if (!frame->executeCommand(WebString::fromUTF8(it->name),
                                WebString::fromUTF8(it->value),
-                               GetFocusedNode()))
+                               GetFocusedElement()))
       break;
     did_execute_command = true;
   }
 
   return did_execute_command;
 }
 
 blink::WebColorChooser* RenderViewImpl::createColorChooser(
     blink::WebColorChooserClient* client,
     const blink::WebColor& initial_color,
@@ skipping 1425 matching lines @@
 }
 
 void RenderViewImpl::SetWebkitPreferences(const WebPreferences& preferences) {
   OnUpdateWebPreferences(preferences);
 }
 
 blink::WebView* RenderViewImpl::GetWebView() {
   return webview();
 }
 
-blink::WebNode RenderViewImpl::GetFocusedNode() const {
+blink::WebElement RenderViewImpl::GetFocusedElement() const {
   if (!webview())
-    return WebNode();
+    return WebElement();
   WebFrame* focused_frame = webview()->focusedFrame();
   if (focused_frame) {
     WebDocument doc = focused_frame->document();
     if (!doc.isNull())
-      return doc.focusedNode();
+      return doc.focusedElement();
   }
 
-  return WebNode();
+  return WebElement();
 }
 
 blink::WebNode RenderViewImpl::GetContextMenuNode() const {
   return context_menu_node_;
 }
 
 bool RenderViewImpl::IsEditableNode(const WebNode& node) const {
   if (node.isNull())
     return false;
 
@@ skipping 213 matching lines @@
   // increment the current match ordinal; we need to re-generate it.
   WebRange current_selection = focused_frame->selectionRange();
 
   do {
     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->executeCommand(WebString::fromUTF8("Unselect"),
-                                   GetFocusedNode());
+                                   GetFocusedElement());
 
       // 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 ?
             search_frame->traverseNext(true) :
             search_frame->traversePrevious(true);
       } while (!search_frame->hasVisibleContent() &&
                search_frame != focused_frame);
 
       // Make sure selection doesn't affect the search operation in new frame.
       search_frame->executeCommand(WebString::fromUTF8("Unselect"),
-                                   GetFocusedNode());
+                                   GetFocusedElement());
 
       // 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(
             request_id, search_text, options, true,  // Force wrapping.
             &selection_rect);
@@ skipping 54 matching lines @@
 
   WebDocument doc = view->mainFrame()->document();
   if (doc.isPluginDocument() && GetWebPluginFromPluginDocument()) {
     GetWebPluginFromPluginDocument()->stopFind();
     return;
   }
 
   bool clear_selection = action == STOP_FIND_ACTION_CLEAR_SELECTION;
   if (clear_selection) {
     view->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"),
-                                         GetFocusedNode());
+                                         GetFocusedElement());
   }
 
   WebFrame* frame = view->mainFrame();
   while (frame) {
     frame->stopFinding(clear_selection);
     frame = frame->traverseNext(false);
   }
 
   if (action == STOP_FIND_ACTION_ACTIVATE_SELECTION) {
     WebFrame* focused_frame = view->focusedFrame();
     if (focused_frame) {
       WebDocument doc = focused_frame->document();
       if (!doc.isNull()) {
-        WebNode node = doc.focusedNode();
-        if (!node.isNull())
-          node.simulateClick();
+        WebElement element = doc.focusedElement();
+        if (!element.isNull())
+          element.simulateClick();
       }
     }
   }
 }
 
 #if defined(OS_ANDROID)
 void RenderViewImpl::OnActivateNearestFindResult(int request_id,
                                                  float x, float y) {
   if (!webview())
       return;
@@ skipping 1659 matching lines @@
   for (size_t i = 0; i < icon_urls.size(); i++) {
     WebURL url = icon_urls[i].iconURL();
     if (!url.isEmpty())
       urls.push_back(FaviconURL(url,
                                 ToFaviconType(icon_urls[i].iconType())));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content