In PageClickTracker, only store last clicked node if it's significant.

chrome/renderer/page_click_tracker.cc

 // Copyright (c) 2010 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/page_click_tracker.h"
 
 #include "chrome/common/render_messages.h"
 #include "chrome/renderer/page_click_listener.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_view.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDOMMouseEvent.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebFrame.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebInputElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebView.h"
 
 using WebKit::WebDOMEvent;
 using WebKit::WebDOMMouseEvent;
 using WebKit::WebElement;
 using WebKit::WebFormControlElement;
 using WebKit::WebFrame;
 using WebKit::WebInputElement;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebNode;
 using WebKit::WebString;
 using WebKit::WebView;
 
+namespace {
+
+// Returns whether |node| is a text input element.

[Jay Civelli, 2011/05/24 04:47:25]

I wonder if we need this method. May be GetTextWebInputElement could return an
empty WebInputElement if the node is not a text webinputelement?

[dpanpong, 2011/05/24 17:10:26]

I like that much better.  Done.

+bool IsTextWebInputElement(const WebNode& node) {
+  if (!node.isElementNode())

[dpanpong, 2011/05/24 01:21:40]

The logic in this function moved from DidHandleMouseEvent().  I changed the
take-by-reference variables to simple variables, because toConst() returns a
temporary, and I became a bit concerned about handling a reference to a
temporary.

+    return false;
+  const WebElement element = node.toConst<WebElement>();
+  if (!element.isFormControlElement())
+    return false;
+  const WebFormControlElement control =
+      element.toConst<WebFormControlElement>();
+  if (control.formControlType() != WebString::fromUTF8("text"))
+    return false;
+  return true;
+}
+
+// Casts |node| to a WebInputElement.
+// |node| must be a web input element.
+const WebInputElement GetTextWebInputElement(const WebNode& node) {
+  const WebElement element = node.toConst<WebElement>();
+  const WebFormControlElement control =
+      element.toConst<WebFormControlElement>();
+  return element.toConst<WebInputElement>();
+}
+
+}  // namespace
+
 PageClickTracker::PageClickTracker(RenderView* render_view)
     : RenderViewObserver(render_view),
       was_focused_(false) {
 }
 
 PageClickTracker::~PageClickTracker() {
   // Note that even though RenderView calls FrameDetached when notified that
   // a frame was closed, it might not always get that notification from WebKit
   // for all frames.
   // By the time we get here, the frame could have been destroyed so we cannot
   // unregister listeners in frames remaining in tracked_frames_ as they might
   // be invalid.
 }
 
 void PageClickTracker::DidHandleMouseEvent(const WebMouseEvent& event) {
   if (event.type != WebInputEvent::MouseDown ||
       last_node_clicked_.isNull()) {
     return;
   }
 
   // We are only interested in text field clicks.
-  if (!last_node_clicked_.isElementNode())
-    return;
-  const WebElement& element = last_node_clicked_.toConst<WebElement>();
-  if (!element.isFormControlElement())
-    return;
-  const WebFormControlElement& control =
-      element.toConst<WebFormControlElement>();
-  if (control.formControlType() != WebString::fromUTF8("text"))
+  if (!IsTextWebInputElement(last_node_clicked_))
     return;
 
-  const WebInputElement& input_element = element.toConst<WebInputElement>();
+  const WebInputElement input_element =
+      GetTextWebInputElement(last_node_clicked_);
 
   bool is_focused = (last_node_clicked_ == GetFocusedNode());
   ObserverListBase<PageClickListener>::Iterator it(listeners_);
   PageClickListener* listener;
   while ((listener = it.GetNext()) != NULL) {
     if (listener->InputElementClicked(input_element, was_focused_, is_focused))
       break;
   }
 
   last_node_clicked_.reset();
@@ skipping 46 matching lines @@
     return;
 
   const WebDOMMouseEvent mouse_event = event.toConst<WebDOMMouseEvent>();
   DCHECK(mouse_event.buttonDown());
   if (mouse_event.button() != 0)
     return;  // We are only interested in left clicks.
 
   // Remember which node has focus before the click is processed.
   // We'll get a notification once the mouse event has been processed
   // (DidHandleMouseEvent), we'll notify the listener at that point.
-  last_node_clicked_ = mouse_event.target();
+  WebNode node = mouse_event.target();
+  // We are only interested in text field clicks.
+  if (!IsTextWebInputElement(node))
+    return;
+
+  last_node_clicked_ = node;
   was_focused_ = (GetFocusedNode() == last_node_clicked_);
 }
 
 WebNode PageClickTracker::GetFocusedNode() {
   WebView* web_view = render_view()->webview();
   if (!web_view)
     return WebNode();
 
   WebFrame* web_frame = web_view->focusedFrame();
   if (!web_frame)
     return WebNode();
 
   return web_frame->document().focusedNode();
 }