Cleanup: Stop creating RenderViewObservers from chrome/ in RenderViewer.

content/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 "content/renderer/render_view.h"
 
 #include <algorithm>
 #include <cmath>
 #include <string>
 #include <vector>
@@ skipping 23 matching lines @@
 #include "chrome/common/extensions/extension_set.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/common/pepper_plugin_registry.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/render_view_commands.h"
 #include "chrome/common/spellcheck_messages.h"
 #include "chrome/common/thumbnail_score.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/web_apps.h"
 #include "chrome/renderer/about_handler.h"
-#include "chrome/renderer/autofill/autofill_agent.h"
 #include "chrome/renderer/autofill/form_manager.h"
-#include "chrome/renderer/autofill/password_autofill_manager.h"
 #include "chrome/renderer/automation/dom_automation_controller.h"
-#include "chrome/renderer/devtools_agent.h"
 #include "chrome/renderer/devtools_client.h"
 #include "chrome/renderer/extension_groups.h"
 #include "chrome/renderer/extensions/bindings_utils.h"
 #include "chrome/renderer/extensions/event_bindings.h"
-#include "chrome/renderer/extensions/extension_helper.h"
 #include "chrome/renderer/extensions/extension_process_bindings.h"
 #include "chrome/renderer/extensions/extension_resource_request_policy.h"
 #include "chrome/renderer/extensions/renderer_extension_bindings.h"
 #include "chrome/renderer/external_host_bindings.h"
 #include "chrome/renderer/localized_error.h"
-#include "chrome/renderer/page_click_tracker.h"
 #include "chrome/renderer/page_load_histograms.h"
-#include "chrome/renderer/print_web_view_helper.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_thread.h"
-#include "chrome/renderer/safe_browsing/malware_dom_details.h"
-#include "chrome/renderer/safe_browsing/phishing_classifier_delegate.h"
-#include "chrome/renderer/searchbox.h"
 #include "chrome/renderer/spellchecker/spellcheck.h"
-#include "chrome/renderer/spellchecker/spellcheck_provider.h"
 #include "chrome/renderer/translate_helper.h"
 #include "chrome/renderer/user_script_idle_scheduler.h"
 #include "chrome/renderer/user_script_slave.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "content/common/appcache/appcache_dispatcher.h"
 #include "content/common/clipboard_messages.h"
 #include "content/common/content_constants.h"
 #include "content/common/database_messages.h"
 #include "content/common/drag_messages.h"
 #include "content/common/file_system/file_system_dispatcher.h"
@@ skipping 191 matching lines @@
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 using WebKit::WebVector;
 using WebKit::WebView;
 using WebKit::WebWidget;
 using WebKit::WebWindowFeatures;
 using WebKit::WebWorker;
 using WebKit::WebWorkerClient;
 using appcache::WebApplicationCacheHostImpl;
-using autofill::AutofillAgent;
 using autofill::FormManager;
-using autofill::PasswordAutofillManager;
 using base::Time;
 using base::TimeDelta;
 using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::FormData;
 using webkit_glue::FormField;
 using webkit_glue::ImageResourceFetcher;
 using webkit_glue::PasswordForm;
 using webkit_glue::PasswordFormDomManager;
 using webkit_glue::ResourceFetcher;
 using webkit_glue::SiteIsolationMetrics;
@@ skipping 215 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,
-                       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)
+                       int64 session_storage_namespace_id)
     : RenderWidget(render_thread, WebKit::WebPopupTypeNone),
       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),
@@ skipping 13 matching lines @@
       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(accessibility_method_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(cookie_jar_(this)),
       devtools_client_(NULL),
       geolocation_dispatcher_(NULL),
       speech_input_dispatcher_(NULL),
       device_orientation_dispatcher_(NULL),
-      print_helper_(NULL),
-      searchbox_(NULL),
-      spellcheck_provider_(NULL),
       accessibility_ack_pending_(false),
       p2p_socket_dispatcher_(NULL),
       pending_app_icon_requests_(0),
       session_storage_namespace_id_(session_storage_namespace_id) {
 
   ClearBlockedContentSettings();
 
   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);
-  PasswordAutofillManager* password_autofill_manager =
-      new PasswordAutofillManager(this);
-  AutofillAgent* autofill_agent = new AutofillAgent(this,
-                                                    password_autofill_manager);
-
-  webwidget_ = WebView::create(this, devtools_agent_, autofill_agent);
+void RenderView::Init(gfx::NativeViewId parent_hwnd,
+                      int32 opener_id,
+                      const RendererPreferences& renderer_prefs,
+                      const string16& frame_name,
+                      WebKit::WebAutoFillClient* autofill_agent,
+                      WebKit::WebDevToolsAgentClient* devtools_agent) {
+  webwidget_ = WebView::create(this, devtools_agent, autofill_agent);
   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);
   webview()->settings()->setMinimumTimerInterval(
       is_hidden() ? webkit_glue::kBackgroundTabTimerInterval :
           webkit_glue::kForegroundTabTimerInterval);
 
   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);
+  } else {
+    opener_id_ = opener_id;
   }
 
   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_autofill_manager);
-  page_click_tracker->AddListener(autofill_agent);
-  new TranslateHelper(this);
-  print_helper_ = new PrintWebViewHelper(this);
-  searchbox_ = new SearchBox(this);
-
-  RenderThread* current_thread = RenderThread::current();
-  SpellCheck* spellcheck = current_thread ? current_thread->spellchecker() : 0;
-  spellcheck_provider_ = new SpellCheckProvider(this, spellcheck);
-
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableP2PApi)) {
     p2p_socket_dispatcher_ = new P2PSocketDispatcher(this);
   }
-
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableClientSidePhishingDetection)) {
-    new safe_browsing::PhishingClassifierDelegate(this, NULL);
-  }
-
-  // Observer for Malware DOM details messages.
-  new safe_browsing::MalwareDOMDetails(this);
-
-  new ExtensionHelper(this);
 }
 
 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 41 matching lines @@
 }
 
 /*static*/
 RenderView* RenderView::FromWebView(WebView* webview) {
   ViewMap* views = g_view_map.Pointer();
   ViewMap::iterator it = views->find(webview);
   return it == views->end() ? NULL : it->second;
 }
 
 /*static*/
-RenderView* RenderView::Create(
-    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) {
+RenderView* RenderView::Create(RenderThreadBase* render_thread,
+                               const WebPreferences& webkit_prefs,
+                               SharedRenderViewCounter* counter,
+                               int32 routing_id,
+                               int64 session_storage_namespace_id) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   return new RenderView(
       render_thread,
-      parent_hwnd,
-      opener_id,
-      renderer_prefs,
       webkit_prefs,
       counter,
       routing_id,
-      session_storage_namespace_id,
-      frame_name);  // adds reference
+      session_storage_namespace_id);  // 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;
 }
@@ skipping 1248 matching lines @@
   bool opener_suppressed = creator->willSuppressOpenerInNewFrame();
 
   render_thread_->Send(
       new ViewHostMsg_CreateWindow(params,
                                    &routing_id,
                                    &cloned_session_storage_namespace_id));
   if (routing_id == MSG_ROUTING_NONE)
     return NULL;
 
   RenderView* view = RenderView::Create(render_thread_,
-                                        0,
-                                        routing_id_,
-                                        renderer_preferences_,
                                         webkit_preferences_,
                                         shared_popup_counter_,
                                         routing_id,
-                                        cloned_session_storage_namespace_id,
-                                        frame_name);
+                                        cloned_session_storage_namespace_id);
+  view->Init(0,
+             routing_id_,
+             renderer_preferences_,
+             frame_name,
+             NULL,
+             NULL);
   view->opened_by_user_gesture_ = params.user_gesture;
 
   // Record whether the creator frame is trying to suppress the opener field.
   view->opener_suppressed_ = opener_suppressed;
 
   // Record the security origin of the creator.
   GURL creator_url(creator->securityOrigin().toString().utf8());
   if (!creator_url.is_valid() || !creator_url.IsStandard())
     creator_url = GURL();
   view->creator_url_ = creator_url;
@@ skipping 48 matching lines @@
 
 void RenderView::didAddMessageToConsole(
     const WebConsoleMessage& message, const WebString& source_name,
     unsigned source_line) {
   Send(new ViewHostMsg_AddMessageToConsole(routing_id_,
                                            UTF16ToWideHack(message.text),
                                            static_cast<int32>(source_line),
                                            UTF16ToWideHack(source_name)));
 }
 
-void RenderView::printPage(WebFrame* frame) {
-  print_helper_->ScriptInitiatedPrint(frame);
+void RenderView::printPage(WebKit::WebFrame* frame) {
+  FOR_EACH_OBSERVER(RenderViewObserver, observers_, printPage(frame));
 }
 
 WebKit::WebNotificationPresenter* RenderView::notificationPresenter() {
   return notification_provider_;
 }
 
 void RenderView::didStartLoading() {
   if (is_loading_) {
     DLOG(WARNING) << "didStartLoading called while loading";
     return;
@@ skipping 159 matching lines @@
   if (thread) {
     thread->spellchecker()->SpellCheckWord(
         word.c_str(), word.size(), document_tag_,
         &misspelled_offset, &misspelled_length, NULL);
   }
 }
 
 void RenderView::requestCheckingOfText(
     const WebString& text,
     WebKit::WebTextCheckingCompletion* completion) {
-  spellcheck_provider_->RequestTextChecking(text, document_tag_, completion);
+  FOR_EACH_OBSERVER(RenderViewObserver,
+                    observers_,
+                    RequestTextChecking(text, document_tag_, completion));

[jam, 2011/03/29 18:31:59]

http://codereview.chromium.org/6764001/ removes the spellchecking functions from
RV completely.  that way, the content layer and the embedder api don't have to
know anything about it

[Lei Zhang, 2011/03/30 22:05:43]

Right, but we still have the spellcheck_provider_ to move out.

 }
 
 WebString RenderView::autoCorrectWord(const WebKit::WebString& word) {
   string16 autocorrect_word;
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kExperimentalSpellcheckerFeatures)) {
     EnsureDocumentTag();
     RenderThread* thread = RenderThread::current();
     // Will be NULL during unit tests.
     if (thread) {
@@ skipping 3103 matching lines @@
     const webkit_glue::CustomContextMenuContext& custom_context) {
   if (custom_context.is_pepper_menu)
     pepper_delegate_.OnContextMenuClosed(custom_context);
   else
     context_menu_node_.reset();
 }
 
 void RenderView::OnNetworkStateChanged(bool online) {
   WebNetworkStateNotifier::setOnLine(online);
 }