Introduce RenderView::Observer interface so that RenderView doesn't have to k...

chrome/renderer/render_view.cc

 // Copyright (c) 2011 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 <cmath>
 #include <string>
 #include <vector>
@@ skipping 489 matching lines @@
     for (uint32_t i = 0 ; i < length ; ++i) {
       list->Set(i, ConvertV8Value(array->Get(i)));
     }
     return list.release();
   }
   return Value::CreateNullValue();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+RenderView::Observer::Observer() : render_view_(NULL), routing_id_(0) {
+}
+
+RenderView::Observer::~Observer() {
+  if (render_view_)
+    render_view_->RemoveObserver(this);
+}
+
+void RenderView::Observer::OnDestruct() {
+  delete this;
+}
+
+bool RenderView::Observer::OnMessageReceived(const IPC::Message& message) {
+  return false;
+}
+
+bool RenderView::Observer::Send(IPC::Message* message) {
+  if (render_view_)
+    return render_view_->Send(message);
+
+  delete message;
+  return false;
+}
+
+void RenderView::Observer::SetRenderView(RenderView* render_view) {
+  render_view_ = render_view;
+  if (render_view_)
+    routing_id_ = render_view_->routing_id();
+}
+
 int32 RenderView::next_page_id_ = 1;
 
 struct RenderView::PendingFileChooser {
   PendingFileChooser(const ViewHostMsg_RunFileChooser_Params& p,
                      WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
   ViewHostMsg_RunFileChooser_Params params;
   WebFileChooserCompletion* completion;  // MAY BE NULL to skip callback.
@@ skipping 21 matching lines @@
 #if defined(OS_MACOSX)
       has_document_tag_(false),
 #endif
       document_tag_(0),
       target_url_status_(TARGET_NONE),
       spelling_panel_visible_(false),
       view_type_(ViewType::INVALID),
       browser_window_id_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(pepper_delegate_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(page_info_method_factory_(this)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(autofill_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(accessibility_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(translate_helper_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
+      devtools_agent_(NULL),
+      devtools_client_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          notification_provider_(new NotificationProvider(this))),
+          notification_provider_(new NotificationProvider())),
+      geolocation_dispatcher_(NULL),
+      speech_input_dispatcher_(NULL),
+      device_orientation_dispatcher_(NULL),
       accessibility_ack_pending_(false),
       pending_app_icon_requests_(0),
       session_storage_namespace_id_(session_storage_namespace_id),
       decrement_shared_popup_at_destruction_(false),
       custom_menu_listener_(NULL) {
 #if defined(OS_MACOSX)
   // On Mac, the select popups are rendered by the browser.
   // Note that we don't do this in RenderMain otherwise this would not be called
   // in single-process mode.
   WebKit::WebView::setUseExternalPopupMenus(true);
 #endif
-  password_autocomplete_manager_.reset(new PasswordAutocompleteManager(this));
-  autofill_helper_.reset(new AutoFillHelper(this));
-  page_click_tracker_.reset(new PageClickTracker(this));
-  // Note that the order of insertion of the listeners is important.
-  // The password_autocomplete_manager_ takes the first shot at processing the
-  // notification and can stop the propagation.
-  page_click_tracker_->AddListener(password_autocomplete_manager_.get());
-  page_click_tracker_->AddListener(autofill_helper_.get());
+
   ClearBlockedContentSettings();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableClientSidePhishingDetection)) {
     phishing_delegate_.reset(
         new safe_browsing::PhishingClassifierDelegate(this, NULL));
     RenderThread* thread = RenderThread::current();
     if (thread && thread->phishing_scorer()) {
       phishing_delegate_->SetPhishingScorer(thread->phishing_scorer());
     }
   }
@@ skipping 31 matching lines @@
   // Tell the PhishingClassifierDelegate that the view is going away.
   if (phishing_delegate_.get())
     phishing_delegate_->CancelPendingClassification();
 
 #ifndef NDEBUG
   // Make sure we are no longer referenced by the ViewMap.
   ViewMap* views = g_view_map.Pointer();
   for (ViewMap::iterator it = views->begin(); it != views->end(); ++it)
     DCHECK_NE(this, it->second) << "Failed to call Close?";
 #endif
+
+  for (size_t i = 0; i < observers_.size(); ++i) {
+    observers_[i]->SetRenderView(NULL);
+    observers_[i]->OnDestruct();
+  }
 }
 
 /*static*/
 void RenderView::ForEach(RenderViewVisitor* visitor) {
   ViewMap* views = g_view_map.Pointer();
   for (ViewMap::iterator it = views->begin(); it != views->end(); ++it) {
     if (!visitor->Visit(it->second))
       return;
   }
 }
@@ skipping 30 matching lines @@
 
 // static
 void RenderView::SetNextPageID(int32 next_page_id) {
   // This method should only be called during process startup, and the given
   // page id had better not exceed our current next page id!
   DCHECK_EQ(next_page_id_, 1);
   DCHECK(next_page_id >= next_page_id_);
   next_page_id_ = next_page_id;
 }
 
+void RenderView::AddObserver(Observer* observer) {
+  observers_.push_back(observer);
+  observer->SetRenderView(this);
+}
+
+void RenderView::RemoveObserver(Observer* observer) {
+  observer->SetRenderView(NULL);
+  for (size_t i = 0; i < observers_.size(); ++i) {
+    if (observers_[i] == observer)
+      observers_.erase(observers_.begin() + i);
+  }
+}
+
 bool RenderView::RendererAccessibilityNotification::ShouldIncludeChildren() {
   typedef ViewHostMsg_AccessibilityNotification_Params params;
   if (type == params::NOTIFICATION_TYPE_CHILDREN_CHANGED ||
       type == params::NOTIFICATION_TYPE_LOAD_COMPLETE) {
     return true;
   }
   return false;
 }
 
 WebKit::WebView* RenderView::webview() const {
@@ skipping 208 matching lines @@
 }
 
 void RenderView::Init(gfx::NativeViewId parent_hwnd,
                       int32 opener_id,
                       const RendererPreferences& renderer_prefs,
                       SharedRenderViewCounter* counter,
                       int32 routing_id,
                       const string16& frame_name) {
   DCHECK(!webview());
 
+  routing_id_ = routing_id;
   if (opener_id != MSG_ROUTING_NONE)
     opener_id_ = opener_id;
 
   if (counter) {
     shared_popup_counter_ = counter;
     shared_popup_counter_->data++;
     decrement_shared_popup_at_destruction_ = true;
   } else {
     shared_popup_counter_ = new SharedRenderViewCounter(0);
     decrement_shared_popup_at_destruction_ = false;
   }
 
-  devtools_agent_.reset(new DevToolsAgent(routing_id, this));
+  devtools_agent_ = new DevToolsAgent(routing_id);
+  PasswordAutocompleteManager* password_autocomplete_manager =
+      new PasswordAutocompleteManager();
+  AutoFillHelper* autofill_helper = new AutoFillHelper(
+      password_autocomplete_manager);

[Ilya Sherman, 2011/01/13 02:18:30]

nit: Might be nice to have a quick comment mentioning how memory is managed for
these.

[jam, 2011/01/13 02:53:43]

There's a comment beside the Observer interface, I'd rather not duplicate it

[Ilya Sherman, 2011/01/13 18:34:50]

That comment is really visible when looking at the changes from this patch, but
a month down the line it'll be harder to know to look there when reading these
lines.  Your call, but I think a (very brief) comment here would be helpful.

[jam, 2011/01/13 18:40:53]

My main issue with documenting stuff multiple times is that they'll go out of
sync, which is more confusing than not having comments.  Also, I think if
someone is using an interface, they should be familiar with it.

[Ilya Sherman, 2011/01/13 22:34:51]

It's not reasonable to expect everyone reading this code to know all of the
details of the Observer interface, and the interface has a decidedly
non-standard approach to memory management.  Without a comment, the immediate
reaction is "Huh, I wonder why there's an unprotected memory allocation."  Sure,
it's not very hard to figure out what's actually going on, but it's an
unnecessary distraction.  A comment like

// Observers will be deleted when the RenderView goes away.

alleviates this; and if it goes out of sync, the code probably needs to be
updated as well.

 
-  // TODO(jam): remove this once WebKit is rolled
-#if defined(WEBKIT_HAS_WEB_AUTO_FILL_CLIENT)
-  webwidget_ = WebView::create(this, devtools_agent_.get(), this);
-#else
-  webwidget_ = WebView::create(this, devtools_agent_.get());
-#endif
+  webwidget_ = WebView::create(this, devtools_agent_, autofill_helper);
   g_view_map.Get().insert(std::make_pair(webview(), this));
   webkit_preferences_.Apply(webview());
   webview()->initializeMainFrame(this);
   if (!frame_name.empty())
     webview()->mainFrame()->setName(frame_name);
 
   OnSetRendererPrefs(renderer_prefs);
 
-  routing_id_ = routing_id;
   render_thread_->AddRoute(routing_id_, this);
   // Take a reference on behalf of the RenderThread.  This will be balanced
   // when we receive ViewMsg_Close.
   AddRef();
 
   // If this is a popup, we must wait for the CreatingNew_ACK message before
   // completing initialization.  Otherwise, we can finish it now.
   if (opener_id == MSG_ROUTING_NONE) {
     did_show_ = true;
     CompleteInit(parent_hwnd);
   }
 
   host_window_ = parent_hwnd;
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDomAutomationController))
     enabled_bindings_ |= BindingsPolicy::DOM_AUTOMATION;
   if (command_line.HasSwitch(switches::kEnableAccessibility))
     WebAccessibilityCache::enableAccessibility();
 
   audio_message_filter_ = new AudioMessageFilter(routing_id_);
   render_thread_->AddFilter(audio_message_filter_);
+
+  PageClickTracker* page_click_tracker = new PageClickTracker();
+  // Note that the order of insertion of the listeners is important.
+  // The password_autocomplete_manager takes the first shot at processing the
+  // notification and can stop the propagation.
+  page_click_tracker->AddListener(password_autocomplete_manager);
+  page_click_tracker->AddListener(autofill_helper);
+
+  AddObserver(autofill_helper);
+  AddObserver(password_autocomplete_manager);
+  AddObserver(page_click_tracker);
+
+  AddObserver(notification_provider_);
+  AddObserver(devtools_agent_);
 }
 
 bool RenderView::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
   if (main_frame)
     child_process_logging::SetActiveURL(main_frame->url());
 
-  // If this is developer tools renderer intercept tools messages first.
-  if (devtools_client_.get() && devtools_client_->OnMessageReceived(message))
-    return true;
-  if (devtools_agent_.get() && devtools_agent_->OnMessageReceived(message))
-    return true;
-  if (notification_provider_->OnMessageReceived(message))
-    return true;
-  if (geolocation_dispatcher_.get() &&
-      geolocation_dispatcher_->OnMessageReceived(message)) {
-    return true;
-  }
-  if (speech_input_dispatcher_.get() &&
-      speech_input_dispatcher_->OnMessageReceived(message)) {
-    return true;
-  }
-  if (device_orientation_dispatcher_.get() &&
-      device_orientation_dispatcher_->OnMessageReceived(message)) {
-    return true;
+  for (size_t i = 0; i < observers_.size(); ++i) {
+    if (observers_[i]->OnMessageReceived(message))
+      return true;
   }
 
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderView, message)
     IPC_MESSAGE_HANDLER(ViewMsg_CaptureThumbnail, OnCaptureThumbnail)
     IPC_MESSAGE_HANDLER(ViewMsg_CaptureSnapshot, OnCaptureSnapshot)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintPages, OnPrintPages)
     IPC_MESSAGE_HANDLER(ViewMsg_PrintingDone, OnPrintingDone)
     IPC_MESSAGE_HANDLER(ViewMsg_Navigate, OnNavigate)
     IPC_MESSAGE_HANDLER(ViewMsg_Stop, OnStop)
@@ skipping 26 matching lines @@
                         OnSetZoomLevelForLoadingURL)
     IPC_MESSAGE_HANDLER(ViewMsg_SetPageEncoding, OnSetPageEncoding)
     IPC_MESSAGE_HANDLER(ViewMsg_ResetPageEncodingToDefault,
                         OnResetPageEncodingToDefault)
     IPC_MESSAGE_HANDLER(ViewMsg_SetupDevToolsClient, OnSetupDevToolsClient)
     IPC_MESSAGE_HANDLER(ViewMsg_DownloadFavIcon, OnDownloadFavIcon)
     IPC_MESSAGE_HANDLER(ViewMsg_ScriptEvalRequest, OnScriptEvalRequest)
     IPC_MESSAGE_HANDLER(ViewMsg_CSSInsertRequest, OnCSSInsertRequest)
     IPC_MESSAGE_HANDLER(ViewMsg_AddMessageToConsole, OnAddMessageToConsole)
     IPC_MESSAGE_HANDLER(ViewMsg_ReservePageIDRange, OnReservePageIDRange)
-    IPC_MESSAGE_HANDLER(ViewMsg_FillPasswordForm, OnFillPasswordForm)
     IPC_MESSAGE_HANDLER(ViewMsg_DragTargetDragEnter, OnDragTargetDragEnter)
     IPC_MESSAGE_HANDLER(ViewMsg_DragTargetDragOver, OnDragTargetDragOver)
     IPC_MESSAGE_HANDLER(ViewMsg_DragTargetDragLeave, OnDragTargetDragLeave)
     IPC_MESSAGE_HANDLER(ViewMsg_DragTargetDrop, OnDragTargetDrop)
     IPC_MESSAGE_HANDLER(ViewMsg_AllowBindings, OnAllowBindings)
     IPC_MESSAGE_HANDLER(ViewMsg_SetDOMUIProperty, OnSetDOMUIProperty)
     IPC_MESSAGE_HANDLER(ViewMsg_DragSourceEndedOrMoved,
                         OnDragSourceEndedOrMoved)
     IPC_MESSAGE_HANDLER(ViewMsg_DragSourceSystemDragEnded,
                         OnDragSourceSystemDragEnded)
@@ skipping 13 matching lines @@
         ViewMsg_GetSerializedHtmlDataForCurrentPageWithLocalLinks,
         OnGetSerializedHtmlDataForCurrentPageWithLocalLinks)
     IPC_MESSAGE_HANDLER(ViewMsg_GetApplicationInfo, OnGetApplicationInfo)
     IPC_MESSAGE_HANDLER(ViewMsg_ShouldClose, OnShouldClose)
     IPC_MESSAGE_HANDLER(ViewMsg_ClosePage, OnClosePage)
     IPC_MESSAGE_HANDLER(ViewMsg_ThemeChanged, OnThemeChanged)
     IPC_MESSAGE_HANDLER(ViewMsg_HandleMessageFromExternalHost,
                         OnHandleMessageFromExternalHost)
     IPC_MESSAGE_HANDLER(ViewMsg_DisassociateFromPopupCount,
                         OnDisassociateFromPopupCount)
-    IPC_MESSAGE_HANDLER(ViewMsg_AutoFillSuggestionsReturned,
-                        OnAutoFillSuggestionsReturned)
-    IPC_MESSAGE_HANDLER(ViewMsg_AutoFillFormDataFilled,
-                        OnAutoFillFormDataFilled)
     IPC_MESSAGE_HANDLER(ViewMsg_AllowScriptToClose,
                         OnAllowScriptToClose)
     IPC_MESSAGE_HANDLER(ViewMsg_MoveOrResizeStarted, OnMoveOrResizeStarted)
     IPC_MESSAGE_HANDLER(ViewMsg_ExtensionResponse, OnExtensionResponse)
     IPC_MESSAGE_HANDLER(ViewMsg_ExtensionMessageInvoke,
                         OnExtensionMessageInvoke)
     IPC_MESSAGE_HANDLER(ViewMsg_ClearFocusedNode, OnClearFocusedNode)
     IPC_MESSAGE_HANDLER(ViewMsg_SetBackground, OnSetBackground)
     IPC_MESSAGE_HANDLER(ViewMsg_EnablePreferredSizeChangedMode,
                         OnEnablePreferredSizeChangedMode)
@@ skipping 301 matching lines @@
   return true;
 }
 
 void RenderView::OnNavigate(const ViewMsg_Navigate_Params& params) {
   if (!webview())
     return;
 
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
 
-  if (devtools_agent_.get())
-    devtools_agent_->OnNavigate();
-
-  if (notification_provider_.get())
-    notification_provider_->OnNavigate();
-
   child_process_logging::SetActiveURL(params.url);
 
   AboutHandler::MaybeHandle(params.url);
 
   bool is_reload =
       params.navigation_type == ViewMsg_Navigate_Params::RELOAD ||
       params.navigation_type == ViewMsg_Navigate_Params::RELOAD_IGNORING_CACHE;
 
   WebFrame* main_frame = webview()->mainFrame();
   if (is_reload && main_frame->currentHistoryItem().isNull()) {
@@ skipping 100 matching lines @@
 void RenderView::OnExecuteEditCommand(const std::string& name,
     const std::string& value) {
   if (!webview() || !webview()->focusedFrame())
     return;
 
   webview()->focusedFrame()->executeCommand(
       WebString::fromUTF8(name), WebString::fromUTF8(value));
 }
 
 void RenderView::OnSetupDevToolsClient() {
-  DCHECK(!devtools_client_.get());
-  devtools_client_.reset(new DevToolsClient(this));
+  DCHECK(!devtools_client_);
+  devtools_client_ = new DevToolsClient(webview());
+  AddObserver(devtools_client_);
 }
 
 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;
@@ skipping 456 matching lines @@
 }
 
 void RenderView::AddGURLSearchProvider(
     const GURL& osd_url,
     const ViewHostMsg_PageHasOSDD_Type& provider_type) {
   if (!osd_url.is_empty())
     Send(new ViewHostMsg_PageHasOSDD(routing_id_, page_id_, osd_url,
                                      provider_type));
 }
 
-void RenderView::OnAutoFillSuggestionsReturned(
-    int query_id,
-    const std::vector<string16>& values,
-    const std::vector<string16>& labels,
-    const std::vector<string16>& icons,
-    const std::vector<int>& unique_ids) {
-  autofill_helper_->SuggestionsReceived(
-      query_id, values, labels, icons, unique_ids);
-}
-
-void RenderView::OnAutoFillFormDataFilled(int query_id,
-                                          const webkit_glue::FormData& form) {
-  autofill_helper_->FormDataFilled(query_id, form);
-}
-
 void RenderView::OnAllowScriptToClose(bool script_can_close) {
   script_can_close_ = script_can_close;
 }
 
 uint32 RenderView::GetCPBrowsingContext() {
   uint32 context = 0;
   Send(new ViewHostMsg_GetCPBrowsingContext(&context));
   return context;
 }
 
@@ skipping 169 matching lines @@
   DCHECK(frame);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePrintPreview)) {
     Print(frame, true, true);
   } else {
     Print(frame, true, false);
   }
 }
 
 WebKit::WebNotificationPresenter* RenderView::notificationPresenter() {
-  return notification_provider_.get();
+  return notification_provider_;
 }
 
 void RenderView::didStartLoading() {
   if (is_loading_) {
     DLOG(WARNING) << "didStartLoading called while loading";
     return;
   }
 
   is_loading_ = true;
   // Clear the pointer so that we can assign it only when there is an unknown
@@ skipping 84 matching lines @@
 
 void RenderView::didExecuteCommand(const WebString& command_name) {
   const std::string& name = UTF16ToUTF8(command_name);
   if (StartsWithASCII(name, "Move", true) ||
       StartsWithASCII(name, "Insert", true) ||
       StartsWithASCII(name, "Delete", true))
     return;
   UserMetricsRecordAction(name);
 }
 
-void RenderView::textFieldDidEndEditing(
-    const WebKit::WebInputElement& element) {
-  password_autocomplete_manager_->TextFieldDidEndEditing(element);
-}
-
-void RenderView::textFieldDidChange(const WebKit::WebInputElement& element) {
-  // We post a task for doing the AutoFill as the caret position is not set
-  // properly at this point (http://bugs.webkit.org/show_bug.cgi?id=16976) and
-  // it is needed to trigger autofill.
-  autofill_method_factory_.RevokeAll();
-  MessageLoop::current()->PostTask(
-        FROM_HERE,
-        autofill_method_factory_.NewRunnableMethod(
-            &RenderView::TextFieldDidChangeImpl, element));
-}
-
-void RenderView::TextFieldDidChangeImpl(
-    const WebKit::WebInputElement& element) {
-  if (password_autocomplete_manager_->TextDidChangeInTextField(element))
-    return;
-  autofill_helper_->TextDidChangeInTextField(element);
-}
-
 void RenderView::SendPendingAccessibilityNotifications() {
   if (!accessibility_.get())
     return;
 
   if (pending_accessibility_notifications_.empty())
     return;
 
   // Send all pending accessibility notifications.
   std::vector<ViewHostMsg_AccessibilityNotification_Params> notifications;
   for (size_t i = 0; i < pending_accessibility_notifications_.size(); i++) {
     RendererAccessibilityNotification& notification =
         pending_accessibility_notifications_[i];
     WebAccessibilityObject obj = accessibility_->getObjectById(notification.id);
     if (!obj.isValid())
       continue;
 
     ViewHostMsg_AccessibilityNotification_Params param;
     param.notification_type = pending_accessibility_notifications_[i].type;
     param.acc_obj = WebAccessibility(
         obj, accessibility_.get(), notification.ShouldIncludeChildren());
     notifications.push_back(param);
   }
   pending_accessibility_notifications_.clear();
   Send(new ViewHostMsg_AccessibilityNotifications(routing_id_, notifications));
   accessibility_ack_pending_ = true;
 }
 
-void RenderView::textFieldDidReceiveKeyDown(
-    const WebKit::WebInputElement& element,
-    const WebKit::WebKeyboardEvent& event) {
-  password_autocomplete_manager_->TextFieldHandlingKeyDown(element, event);
-  autofill_helper_->KeyDownInTextField(element, event);
-}
-
 bool RenderView::handleCurrentKeyboardEvent() {
   if (edit_commands_.empty())
     return false;
 
   WebFrame* frame = webview()->focusedFrame();
   if (!frame)
     return false;
 
   EditCommands::iterator it = edit_commands_.begin();
   EditCommands::iterator end = edit_commands_.end();
@@ skipping 272 matching lines @@
   return history_list_length_ - historyBackListCount() - 1;
 }
 
 void RenderView::didUpdateInspectorSetting(const WebString& key,
                                            const WebString& value) {
   Send(new ViewHostMsg_UpdateInspectorSetting(routing_id_,
                                               key.utf8(),
                                               value.utf8()));
 }
 
-void RenderView::didAcceptAutoFillSuggestion(const WebKit::WebNode& node,
-                                             const WebKit::WebString& value,
-                                             const WebKit::WebString& label,
-                                             int unique_id,
-                                             unsigned index) {
-  autofill_helper_->DidAcceptAutoFillSuggestion(node, value, unique_id, index);
-}
-
-void RenderView::didSelectAutoFillSuggestion(const WebKit::WebNode& node,
-                                             const WebKit::WebString& value,
-                                             const WebKit::WebString& label,
-                                             int unique_id) {
-  autofill_helper_->DidSelectAutoFillSuggestion(node, unique_id);
-}
-
-void RenderView::didClearAutoFillSelection(const WebKit::WebNode& node) {
-  autofill_helper_->DidClearAutoFillSelection(node);
-}
-
-void RenderView::didAcceptAutocompleteSuggestion(
-    const WebKit::WebInputElement& user_element) {
-  bool result = password_autocomplete_manager_->FillPassword(user_element);
-  // Since this user name was selected from a suggestion list, we should always
-  // have password for it.
-  DCHECK(result);
-}
-
-void RenderView::removeAutocompleteSuggestion(const WebKit::WebString& name,
-                                              const WebKit::WebString& value) {
-  autofill_helper_->RemoveAutocompleteSuggestion(name, value);
-}
-
-void RenderView::removeAutofillSuggestions(const WebString& name,
-                                           const WebString& value) {
-  removeAutocompleteSuggestion(name, value);
-}
-
 // WebKit::WebWidgetClient ----------------------------------------------------
 
 void RenderView::didFocus() {
   // TODO(jcivelli): when https://bugs.webkit.org/show_bug.cgi?id=33389 is fixed
   //                 we won't have to test for user gesture anymore and we can
   //                 move that code back to render_widget.cc
   if (webview() && webview()->mainFrame() &&
       webview()->mainFrame()->isProcessingUserGesture()) {
     Send(new ViewHostMsg_Focus(routing_id_));
   }
@@ skipping 235 matching lines @@
   return new RendererWebApplicationCacheHostImpl(
       FromWebView(frame->view()), client,
       RenderThread::current()->appcache_dispatcher()->backend_proxy());
 }
 
 WebCookieJar* RenderView::cookieJar(WebFrame* frame) {
   return &cookie_jar_;
 }
 
 void RenderView::frameDetached(WebFrame* frame) {
-  autofill_helper_->FrameDetached(frame);
-  page_click_tracker_->StopTrackingFrame(frame, true);
+  for (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->FrameDetached(frame);
 }
 
 void RenderView::willClose(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
 
   page_load_histograms_.Dump(frame);
   navigation_state->user_script_idle_scheduler()->Cancel();
 
-  // TODO(jhawkins): Remove once frameDetached is called by WebKit.
-  // NOTE: taking this out results in lots of increased memory usage!  This is
-  // because frameDetached is NOT like wilLClose.  The latter happens between
-  // navigations, but the former only happens when the RenderView is going away.
-  autofill_helper_->FrameWillClose(frame);
+  for (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->FrameWillClose(frame);
 }
 
 bool RenderView::allowImages(WebFrame* frame, bool enabled_per_settings) {
   if (enabled_per_settings &&
       AllowContentType(CONTENT_SETTINGS_TYPE_IMAGES))
     return true;
 
   if (IsWhitelistedForContentSettings(frame))
     return true;
 
@@ skipping 573 matching lines @@
 }
 
 void RenderView::didFinishDocumentLoad(WebFrame* frame) {
   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_, frame->identifier()));
 
-  page_click_tracker_->StartTrackingFrame(frame);
-  // The document has now been fully loaded.  Scan for forms to be sent up to
-  // the browser.
-  autofill_helper_->FrameContentsAvailable(frame);
-  password_autocomplete_manager_->SendPasswordForms(frame, false);
+  for (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->DidFinishDocumentLoad(frame);
 
   // Check whether we have new encoding name.
   UpdateEncoding(frame, frame->view()->pageEncoding().utf8());
 
   if (RenderThread::current()) {  // Will be NULL during unit tests.
     RenderThread::current()->user_script_slave()->InjectScripts(
         frame, UserScript::DOCUMENT_END);
   }
 
   // InjectScripts() can end up creating a new NavigationState if it triggers a
@@ skipping 30 matching lines @@
   // Ignore
 }
 
 void RenderView::didFinishLoad(WebFrame* frame) {
   WebDataSource* ds = frame->dataSource();
   NavigationState* navigation_state = NavigationState::FromDataSource(ds);
   DCHECK(navigation_state);
   navigation_state->set_finish_load_time(Time::Now());
   navigation_state->user_script_idle_scheduler()->DidFinishLoad();
 
-  // Let the password manager know which password forms are actually visible.
-  password_autocomplete_manager_->SendPasswordForms(frame, true);
+  for (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->DidFinishLoad(frame);
 
   Send(new ViewHostMsg_DidFinishLoad(routing_id_, frame->identifier()));
 }
 
 void RenderView::didNavigateWithinPage(
     WebFrame* frame, bool is_new_navigation) {
   // Determine if the UserScriptIdleScheduler already ran scripts on this page,
   // since a new one gets created by didCreateDataSource.
   NavigationState* state = NavigationState::FromDataSource(frame->dataSource());
   bool idle_scheduler_ran = state->user_script_idle_scheduler()->has_run();
@@ skipping 1093 matching lines @@
     webview()->dragSourceEndedAt(client_point, screen_point, op);
   } else {
     webview()->dragSourceMovedTo(client_point, screen_point, op);
   }
 }
 
 void RenderView::OnDragSourceSystemDragEnded() {
   webview()->dragSourceSystemDragEnded();
 }
 
-void RenderView::OnFillPasswordForm(
-    const webkit_glue::PasswordFormFillData& form_data) {
-  password_autocomplete_manager_->ReceivedPasswordFormFillData(webview(),
-                                                              form_data);
-}
-
 void RenderView::OnDragTargetDragEnter(const WebDropData& drop_data,
                                        const gfx::Point& client_point,
                                        const gfx::Point& screen_point,
                                        WebDragOperationsMask ops) {
   WebDragOperation operation = webview()->dragTargetDragEnter(
       drop_data.ToDragData(),
       drop_data.identity,
       client_point,
       screen_point,
       ops);
@@ skipping 751 matching lines @@
   // We need to grab a pointer to the doomed WebView before we destroy it.
   WebView* doomed = webview();
   RenderWidget::Close();
   g_view_map.Get().erase(doomed);
 }
 
 void RenderView::DidHandleKeyEvent() {
   edit_commands_.clear();
 }
 
-void RenderView::DidHandleMouseEvent(const WebKit::WebMouseEvent& event) {
-  page_click_tracker_->DidHandleMouseEvent(event);
-}
-
 #if defined(OS_MACOSX)
 void RenderView::OnWasHidden() {
   RenderWidget::OnWasHidden();
 
   // Inform plugins that their container is no longer visible.
   std::set<WebPluginDelegateProxy*>::iterator plugin_it;
   for (plugin_it = plugin_delegates_.begin();
        plugin_it != plugin_delegates_.end(); ++plugin_it) {
     (*plugin_it)->SetContainerVisibility(false);
   }
@@ skipping 135 matching lines @@
     Send(new ViewHostMsg_RunFileChooser(routing_id_, params));
   }
   return true;
 }
 
 void RenderView::OnPageTranslated() {
   WebFrame* frame = webview()->mainFrame();
   if (!frame)
     return;
 
-  // The page is translated, so try to extract the form data again.
-  autofill_helper_->FrameContentsAvailable(frame);
+  for (size_t i = 0; i < observers_.size(); ++i)
+    observers_[i]->FrameTranslated(frame);
 }
 
 WebKit::WebGeolocationClient* RenderView::geolocationClient() {
-  if (!geolocation_dispatcher_.get())
-    geolocation_dispatcher_.reset(new GeolocationDispatcher(this));
-  return geolocation_dispatcher_.get();
+  if (!geolocation_dispatcher_) {
+    geolocation_dispatcher_ = new GeolocationDispatcher();
+    AddObserver(geolocation_dispatcher_);
+  }
+  return geolocation_dispatcher_;
 }
 
 WebKit::WebSpeechInputController* RenderView::speechInputController(
     WebKit::WebSpeechInputListener* listener) {
-  if (!speech_input_dispatcher_.get())
-    speech_input_dispatcher_.reset(new SpeechInputDispatcher(this, listener));
-  return speech_input_dispatcher_.get();
+  if (!speech_input_dispatcher_) {
+    speech_input_dispatcher_ = new SpeechInputDispatcher(listener);
+    AddObserver(speech_input_dispatcher_);
+  }
+  return speech_input_dispatcher_;
 }
 
 WebKit::WebDeviceOrientationClient* RenderView::deviceOrientationClient() {
-  if (!device_orientation_dispatcher_.get())
-    device_orientation_dispatcher_.reset(new DeviceOrientationDispatcher(this));
-  return device_orientation_dispatcher_.get();
+  if (!device_orientation_dispatcher_) {
+    device_orientation_dispatcher_ = new DeviceOrientationDispatcher();
+    AddObserver(device_orientation_dispatcher_);
+  }
+  return device_orientation_dispatcher_;
 }
 
 void RenderView::zoomLimitsChanged(double minimum_level, double maximum_level) {
   // For now, don't remember plugin zoom values.  We don't want to mix them with
   // normal web content (i.e. a fixed layout plugin would usually want them
   // different).
   bool remember = !webview()->mainFrame()->document().isPluginDocument();
 
   int minimum_percent = static_cast<int>(
       WebView::zoomLevelToZoomFactor(minimum_level) * 100);
@@ skipping 106 matching lines @@
 }
 #endif
 
 void RenderView::OnJavaScriptStressTestControl(int cmd, int param) {
   if (cmd == kJavaScriptStressTestSetStressRunType) {
     v8::Testing::SetStressRunType(static_cast<v8::Testing::StressType>(param));
   } else if (cmd == kJavaScriptStressTestPrepareStressRun) {
     v8::Testing::PrepareStressRun(param);
   }
 }