Introduce CompositorDependencies for RenderWidgetCompositor.

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 369 matching lines @@
 static bool DeviceScaleEnsuresTextQuality(float device_scale_factor) {
 #if defined(OS_ANDROID)
   // On Android, we never have subpixel antialiasing.
   return true;
 #else
   return device_scale_factor > 1.5f;
 #endif
 
 }
 
-static bool PreferCompositingToLCDText(float device_scale_factor) {
+static bool PreferCompositingToLCDText(CompositorDependencies* compositor_deps,
+                                       float device_scale_factor) {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kDisablePreferCompositingToLCDText))
     return false;
   if (command_line.HasSwitch(switches::kEnablePreferCompositingToLCDText))
     return true;
-  if (RenderThreadImpl::current() &&
-      !RenderThreadImpl::current()->is_lcd_text_enabled())
+  if (!compositor_deps->IsLcdTextEnabled())
     return true;
   return DeviceScaleEnsuresTextQuality(device_scale_factor);
 }
 
 static FaviconURL::IconType ToFaviconType(blink::WebIconURL::Type type) {
   switch (type) {
     case blink::WebIconURL::TypeFavicon:
       return FaviconURL::FAVICON;
     case blink::WebIconURL::TypeTouch:
       return FaviconURL::TOUCH_ICON;
@@ skipping 257 matching lines @@
 #if defined(ENABLE_PLUGINS)
       plugin_find_handler_(NULL),
       focused_pepper_plugin_(NULL),
       pepper_last_mouse_event_target_(NULL),
 #endif
       enumeration_completion_id_(0),
       session_storage_namespace_id_(params.session_storage_namespace_id),
       next_snapshot_id_(0) {
 }
 
-void RenderViewImpl::Initialize(
-    const ViewMsg_New_Params& params,
-    bool was_created_by_renderer) {
+void RenderViewImpl::Initialize(const ViewMsg_New_Params& params,
+                                CompositorDependencies* compositor_deps,
+                                bool was_created_by_renderer) {
   routing_id_ = params.view_id;
   surface_id_ = params.surface_id;
   if (params.opener_route_id != MSG_ROUTING_NONE && was_created_by_renderer)
     opener_id_ = params.opener_route_id;
 
   // Ensure we start with a valid next_page_id_ from the browser.
   DCHECK_GE(next_page_id_, 0);
 
   main_render_frame_.reset(RenderFrameImpl::Create(
       this, params.main_frame_routing_id));
   // The main frame WebLocalFrame object is closed by
   // RenderFrameImpl::frameDetached().
   WebLocalFrame* web_frame = WebLocalFrame::create(main_render_frame_.get());
   main_render_frame_->SetWebFrame(web_frame);
 
+  compositor_deps_ = compositor_deps;
   webwidget_ = WebView::create(this);
   webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
   if (command_line.HasSwitch(switches::kStatsCollectionController))
     stats_collection_observer_.reset(new StatsCollectionObserver(this));
 
 #if defined(OS_ANDROID)
   const std::string region_code =
@@ skipping 24 matching lines @@
   // completing initialization.  Otherwise, we can finish it now.
   if (opener_id_ == MSG_ROUTING_NONE) {
     did_show_ = true;
     CompleteInit();
   }
 
   g_view_map.Get().insert(std::make_pair(webview(), this));
   g_routing_id_view_map.Get().insert(std::make_pair(routing_id_, this));
   webview()->setDeviceScaleFactor(device_scale_factor_);
   webview()->settings()->setPreferCompositingToLCDTextEnabled(
-      PreferCompositingToLCDText(device_scale_factor_));
+      PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
   webview()->settings()->setThreadedScrollingEnabled(
       !command_line.HasSwitch(switches::kDisableThreadedScrolling));
   webview()->settings()->setRootLayerScrolls(
       command_line.HasSwitch(switches::kRootLayerScrolls));
 
   ApplyWebPreferences(webkit_preferences_, webview());
 
   webview()->settings()->setAllowConnectingInsecureWebSocket(
       command_line.HasSwitch(switches::kAllowInsecureWebSocketFromHttpsOrigin));
 
   RenderFrameProxy* proxy = NULL;
   if (params.proxy_routing_id != MSG_ROUTING_NONE) {
     CHECK(params.swapped_out);
     proxy = RenderFrameProxy::CreateProxyToReplaceFrame(
         main_render_frame_.get(), params.proxy_routing_id);
     main_render_frame_->set_render_frame_proxy(proxy);
   }
 
   // In --site-per-process, just use the WebRemoteFrame as the main frame.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kSitePerProcess) &&
-      proxy) {
+  if (command_line.HasSwitch(switches::kSitePerProcess) && proxy) {
     webview()->setMainFrame(proxy->web_frame());
     // Initialize the WebRemoteFrame with information replicated from the
     // browser process.
     proxy->SetReplicatedState(params.replicated_frame_state);
   } else {
     webview()->setMainFrame(main_render_frame_->GetWebFrame());
   }
   main_render_frame_->Initialize();
 
   if (switches::IsTouchDragDropEnabled())
@@ skipping 357 matching lines @@
   settings->setRubberBandingOnCompositorThread(
       prefs.rubber_banding_on_compositor_thread);
   settings->setUseSolidColorScrollbars(prefs.use_solid_color_scrollbars);
 
 #if defined(OS_WIN)
   settings->setShowContextMenuOnMouseUp(true);
 #endif
 }
 
 /*static*/
-RenderViewImpl* RenderViewImpl::Create(
-    const ViewMsg_New_Params& params,
-    bool was_created_by_renderer) {
+RenderViewImpl* RenderViewImpl::Create(const ViewMsg_New_Params& params,
+                                       CompositorDependencies* compositor_deps,
+                                       bool was_created_by_renderer) {
   DCHECK(params.view_id != MSG_ROUTING_NONE);
   RenderViewImpl* render_view = NULL;
   if (g_create_render_view_impl)
     render_view = g_create_render_view_impl(params);
   else
     render_view = new RenderViewImpl(params);
 
-  render_view->Initialize(params, was_created_by_renderer);
+  render_view->Initialize(params, compositor_deps, was_created_by_renderer);
   return render_view;
 }
 
 // static
 void RenderViewImpl::InstallCreateHook(
     RenderViewImpl* (*create_render_view_impl)(const ViewMsg_New_Params&)) {
   CHECK(!g_create_render_view_impl);
   g_create_render_view_impl = create_render_view_impl;
 }
 
@@ skipping 418 matching lines @@
   params.features = features;
 
   for (size_t i = 0; i < features.additionalFeatures.size(); ++i)
     params.additional_features.push_back(features.additionalFeatures[i]);
 
   int32 routing_id = MSG_ROUTING_NONE;
   int32 main_frame_routing_id = MSG_ROUTING_NONE;
   int32 surface_id = 0;
   int64 cloned_session_storage_namespace_id = 0;
 
-  RenderThread::Get()->Send(
-      new ViewHostMsg_CreateWindow(params,
-                                   &routing_id,
-                                   &main_frame_routing_id,
-                                   &surface_id,
-                                   &cloned_session_storage_namespace_id));
+  RenderThread::Get()->Send(new ViewHostMsg_CreateWindow(
+      params, &routing_id, &main_frame_routing_id, &surface_id,
+      &cloned_session_storage_namespace_id));
   if (routing_id == MSG_ROUTING_NONE)
     return NULL;
 
   WebUserGestureIndicator::consumeUserGesture();
 
   // While this view may be a background extension page, it can spawn a visible
   // render view. So we just assume that the new one is not another background
   // page instead of passing on our own value.
   // TODO(vangelis): Can we tell if the new view will be a background page?
   bool never_visible = false;
@@ skipping 22 matching lines @@
   view_params.replicated_frame_state = FrameReplicationState();
   view_params.proxy_routing_id = MSG_ROUTING_NONE;
   view_params.hidden = (params.disposition == NEW_BACKGROUND_TAB);
   view_params.never_visible = never_visible;
   view_params.next_page_id = 1;
   view_params.initial_size = initial_size;
   view_params.enable_auto_resize = false;
   view_params.min_size = gfx::Size();
   view_params.max_size = gfx::Size();
 
-  RenderViewImpl* view = RenderViewImpl::Create(view_params, true);
+  RenderViewImpl* view =
+      RenderViewImpl::Create(view_params, compositor_deps_, true);
   view->opened_by_user_gesture_ = params.user_gesture;
 
   // Record whether the creator frame is trying to suppress the opener field.
   view->opener_suppressed_ = params.opener_suppressed;
 
   return view->webview();
 }
 
 WebWidget* RenderViewImpl::createPopupMenu(blink::WebPopupType popup_type) {
-  RenderWidget* widget =
-      RenderWidget::Create(routing_id_, popup_type, screen_info_);
+  RenderWidget* widget = RenderWidget::Create(routing_id_, compositor_deps_,
+                                              popup_type, screen_info_);
   if (!widget)
     return NULL;
   if (screen_metrics_emulator_) {
     widget->SetPopupOriginAdjustmentsForEmulation(
         screen_metrics_emulator_.get());
   }
   return widget->webwidget();
 }
 
 WebStorageNamespace* RenderViewImpl::createSessionStorageNamespace() {
@@ skipping 1927 matching lines @@
   RenderWidget::OnImeConfirmComposition(text,
                                         replacement_range,
                                         keep_selection);
 }
 
 void RenderViewImpl::SetDeviceScaleFactor(float device_scale_factor) {
   RenderWidget::SetDeviceScaleFactor(device_scale_factor);
   if (webview()) {
     webview()->setDeviceScaleFactor(device_scale_factor);
     webview()->settings()->setPreferCompositingToLCDTextEnabled(
-        PreferCompositingToLCDText(device_scale_factor_));
+        PreferCompositingToLCDText(compositor_deps_, device_scale_factor_));
   }
   if (auto_resize_mode_)
     AutoResizeCompositor();
 
   if (browser_plugin_manager_.get())
     browser_plugin_manager_->UpdateDeviceScaleFactor();
 }
 
 bool RenderViewImpl::SetDeviceColorProfile(
     const std::vector<char>& profile) {
@@ skipping 503 matching lines @@
     std::vector<gfx::Size> sizes;
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content