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 60 matching lines @@
 #include "chrome/renderer/media/ipc_video_decoder.h"
 #include "chrome/renderer/navigation_state.h"
 #include "chrome/renderer/notification_provider.h"
 #include "chrome/renderer/page_click_tracker.h"
 #include "chrome/renderer/page_load_histograms.h"
 #include "chrome/renderer/password_autocomplete_manager.h"
 #include "chrome/renderer/plugin_channel_host.h"
 #include "chrome/renderer/print_web_view_helper.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_thread.h"
+#include "chrome/renderer/render_view_observer.h"
 #include "chrome/renderer/render_view_visitor.h"
 #include "chrome/renderer/render_widget_fullscreen.h"
 #include "chrome/renderer/render_widget_fullscreen_pepper.h"
 #include "chrome/renderer/renderer_webapplicationcachehost_impl.h"
 #include "chrome/renderer/renderer_webstoragenamespace_impl.h"
 #include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
 #include "chrome/renderer/searchbox_extension.h"
 #include "chrome/renderer/speech_input_dispatcher.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
 #include "chrome/renderer/user_script_idle_scheduler.h"
@@ skipping 422 matching lines @@
   PendingFileChooser(const ViewHostMsg_RunFileChooser_Params& p,
                      WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
   ViewHostMsg_RunFileChooser_Params params;
   WebFileChooserCompletion* completion;  // MAY BE NULL to skip callback.
 };
 
 RenderView::RenderView(RenderThreadBase* render_thread,
-                       const WebPreferences& webkit_preferences,
-                       int64 session_storage_namespace_id)
+                       gfx::NativeViewId parent_hwnd,
+                       int32 opener_id,
+                       const RendererPreferences& renderer_prefs,
+                       const WebPreferences& webkit_prefs,
+                       SharedRenderViewCounter* counter,
+                       int32 routing_id,
+                       int64 session_storage_namespace_id,
+                       const string16& frame_name)
     : RenderWidget(render_thread, WebKit::WebPopupTypeNone),
-      webkit_preferences_(webkit_preferences),
+      webkit_preferences_(webkit_prefs),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       script_can_close_(true),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
       page_id_(-1),
       last_page_id_sent_to_browser_(-1),
       last_indexed_page_id_(-1),
       history_list_offset_(-1),
       history_list_length_(0),
       has_unload_listener_(false),
 #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)),
-      ALLOW_THIS_IN_INITIALIZER_LIST(
-          notification_provider_(new NotificationProvider(this))),
+      devtools_client_(NULL),
+      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());
     }
   }
+
+  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;
+  }
+
+  notification_provider_ = new NotificationProvider(this);
+
+  devtools_agent_ = new DevToolsAgent(this);
+  PasswordAutocompleteManager* password_autocomplete_manager =
+      new PasswordAutocompleteManager(this);
+  AutoFillHelper* autofill_helper = new AutoFillHelper(
+      this, password_autocomplete_manager);
+
+  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);
+
+  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(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);
+  page_click_tracker->AddListener(autofill_helper);
 }
 
 RenderView::~RenderView() {
   if (decrement_shared_popup_at_destruction_)
     shared_popup_counter_->data--;
 
   // If file chooser is still waiting for answer, dispatch empty answer.
   while (!file_chooser_completions_.empty()) {
     if (file_chooser_completions_.front()->completion) {
       file_chooser_completions_.front()->completion->didChooseFile(
@@ skipping 21 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_EACH_OBSERVER(RenderViewObserver, observers_, set_render_view(NULL));
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, 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 10 matching lines @@
     RenderThreadBase* render_thread,
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
     const RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int64 session_storage_namespace_id,
     const string16& frame_name) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
-  scoped_refptr<RenderView> view(new RenderView(render_thread, webkit_prefs,
-                                                session_storage_namespace_id));
-  view->Init(parent_hwnd,
-             opener_id,
-             renderer_prefs,
-             counter,
-             routing_id,
-             frame_name);  // adds reference
-  return view;
+  return new RenderView(
+      render_thread,
+      parent_hwnd,
+      opener_id,
+      renderer_prefs,
+      webkit_prefs,
+      counter,
+      routing_id,
+      session_storage_namespace_id,
+      frame_name);  // adds reference
 }
 
 // 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(RenderViewObserver* observer) {
+  observers_.AddObserver(observer);
+}
+
+void RenderView::RemoveObserver(RenderViewObserver* observer) {
+  observer->set_render_view(NULL);
+  observers_.RemoveObserver(observer);
+}
+
 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 200 matching lines @@
 }
 
 void RenderView::RegisterBlockedPlugin(BlockedPlugin* blocked_plugin) {
   blocked_plugins_.insert(blocked_plugin);
 }
 
 void RenderView::UnregisterBlockedPlugin(BlockedPlugin* blocked_plugin) {
   blocked_plugins_.erase(blocked_plugin);
 }
 
-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());
-
-  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));
-
-  // 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
-  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_);
-}
-
 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;
-  }
+  ObserverListBase<RenderViewObserver>::Iterator it(observers_);
+  RenderViewObserver* observer;
+  while ((observer = it.GetNext()) != NULL)
+    if (observer->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)
     IPC_MESSAGE_HANDLER(ViewMsg_ReloadFrame, OnReloadFrame)
@@ skipping 25 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(this);
 }
 
 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_EACH_OBSERVER(RenderViewObserver, observers_, 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_EACH_OBSERVER(RenderViewObserver, observers_, 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_EACH_OBSERVER(
+      RenderViewObserver, observers_, 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_EACH_OBSERVER(RenderViewObserver, observers_, 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 752 matching lines @@
   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);
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, 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) {
@@ skipping 137 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_EACH_OBSERVER(RenderViewObserver, observers_, 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(this);
+  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(this, listener);
+  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(this);
+  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);
   }
 }