Remove non-impl-side painting as an option for blink.

content/renderer/render_thread_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_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 557 matching lines @@
 
   AddFilter((new ServiceWorkerContextMessageFilter())->GetFilter());
 
   GetContentClient()->renderer()->RenderThreadStarted();
 
   InitSkiaEventTracer();
 
   const base::CommandLine& command_line =
       *base::CommandLine::ForCurrentProcess();
 
-  is_impl_side_painting_enabled_ =
-      !command_line.HasSwitch(switches::kDisableImplSidePainting);
-  cc_blink::WebLayerImpl::SetImplSidePaintingEnabled(
-      is_impl_side_painting_enabled_);
-
   cc::LayerSettings layer_settings;
   if (command_line.HasSwitch(switches::kEnableCompositorAnimationTimelines))
     layer_settings.use_compositor_animation_timelines = true;
   cc_blink::WebLayerImpl::SetLayerSettings(layer_settings);
 
   is_zero_copy_enabled_ = command_line.HasSwitch(switches::kEnableZeroCopy);
   is_one_copy_enabled_ = !command_line.HasSwitch(switches::kDisableOneCopy);
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   is_elastic_overscroll_enabled_ = base::mac::IsOSLionOrLater();
@@ skipping 56 matching lines @@
   // been initialized by the Zygote before this instance became a Renderer.
   media::InitializeMediaLibrary();
 
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&RenderThreadImpl::OnMemoryPressure, base::Unretained(this))));
 
   compositor_task_graph_runner_.reset(new cc::TaskGraphRunner);
 
   is_gather_pixel_refs_enabled_ = false;
 
-  if (is_impl_side_painting_enabled_) {
-    int num_raster_threads = 0;
-    std::string string_value =
-        command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
-    bool parsed_num_raster_threads =
-        base::StringToInt(string_value, &num_raster_threads);
-    DCHECK(parsed_num_raster_threads) << string_value;
-    DCHECK_GT(num_raster_threads, 0);
+  int num_raster_threads = 0;
+  std::string string_value =
+      command_line.GetSwitchValueASCII(switches::kNumRasterThreads);
+  bool parsed_num_raster_threads =
+      base::StringToInt(string_value, &num_raster_threads);
+  DCHECK(parsed_num_raster_threads) << string_value;
+  DCHECK_GT(num_raster_threads, 0);
 
-    // Note: Currently, gathering of pixel refs when using a single
-    // raster thread doesn't provide any benefit. This might change
-    // in the future but we avoid it for now to reduce the cost of
-    // Picture::Create.
-    is_gather_pixel_refs_enabled_ = num_raster_threads > 1;
+  // Note: Currently, gathering of pixel refs when using a single
+  // raster thread doesn't provide any benefit. This might change
+  // in the future but we avoid it for now to reduce the cost of
+  // Picture::Create.
+  is_gather_pixel_refs_enabled_ = num_raster_threads > 1;
 
-    base::SimpleThread::Options thread_options;
+  base::SimpleThread::Options thread_options;
 #if defined(OS_ANDROID) || defined(OS_LINUX)
-    if (!command_line.HasSwitch(
-            switches::kUseNormalPriorityForTileTaskWorkerThreads)) {
-      thread_options.set_priority(base::ThreadPriority::BACKGROUND);
-    }
+  if (!command_line.HasSwitch(
+          switches::kUseNormalPriorityForTileTaskWorkerThreads)) {
+    thread_options.set_priority(base::ThreadPriority::BACKGROUND);
+  }
 #endif
-    while (compositor_raster_threads_.size() <
-           static_cast<size_t>(num_raster_threads)) {
-      scoped_ptr<CompositorRasterThread> raster_thread(
-          new CompositorRasterThread(
-              compositor_task_graph_runner_.get(),
-              base::StringPrintf(
-                  "CompositorTileWorker%u",
-                  static_cast<unsigned>(compositor_raster_threads_.size() + 1))
-                  .c_str(),
-              thread_options));
-      raster_thread->Start();
-      compositor_raster_threads_.push_back(raster_thread.Pass());
-    }
+  while (compositor_raster_threads_.size() <
+         static_cast<size_t>(num_raster_threads)) {
+    scoped_ptr<CompositorRasterThread> raster_thread(new CompositorRasterThread(
+        compositor_task_graph_runner_.get(),
+        base::StringPrintf("CompositorTileWorker%u",
+                           static_cast<unsigned>(
+                               compositor_raster_threads_.size() + 1)).c_str(),
+        thread_options));
+    raster_thread->Start();
+    compositor_raster_threads_.push_back(raster_thread.Pass());
   }
 
   // In single process, browser main loop set up the discardable memory
   // allocator.
   if (!command_line.HasSwitch(switches::kSingleProcess)) {
     base::DiscardableMemoryAllocator::SetInstance(
         ChildThreadImpl::discardable_shared_memory_manager());
   }
 
   service_registry()->AddService<RenderFrameSetup>(
@@ skipping 409 matching lines @@
   devtools_agent_message_filter_ = new DevToolsAgentFilter();
   AddFilter(devtools_agent_message_filter_.get());
 
   v8_sampling_profiler_.reset(new V8SamplingProfiler());
 
   if (GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
     ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 
   cc_blink::SetSharedBitmapAllocationFunction(AllocateSharedBitmapFunction);
 
-  // Limit use of the scaled image cache to when deferred image decoding is
-  // enabled.
-  if (!command_line.HasSwitch(switches::kEnableDeferredImageDecoding) &&
-      !is_impl_side_painting_enabled_)
-    SkGraphics::SetResourceCacheTotalByteLimit(0u);
-
   SkGraphics::SetResourceCacheSingleAllocationByteLimit(
       kImageCacheSingleAllocationByteLimit);
 
   if (command_line.HasSwitch(switches::kMemoryMetrics)) {
     memory_observer_.reset(new MemoryObserver());
     message_loop()->AddTaskObserver(memory_observer_.get());
   }
 
   if (command_line.HasSwitch(switches::kExplicitlyAllowedPorts)) {
     std::string allowed_ports =
@@ skipping 245 matching lines @@
                                               const base::string16& str) {
   Send(new ViewHostMsg_PreCacheFontCharacters(log_font, str));
 }
 
 #endif  // OS_WIN
 
 ServiceRegistry* RenderThreadImpl::GetServiceRegistry() {
   return service_registry();
 }
 
-bool RenderThreadImpl::IsImplSidePaintingEnabled() {
-  return is_impl_side_painting_enabled_;
-}
-
 bool RenderThreadImpl::IsGpuRasterizationForced() {
   return is_gpu_rasterization_forced_;
 }
 
 bool RenderThreadImpl::IsGpuRasterizationEnabled() {
   return is_gpu_rasterization_enabled_;
 }
 
 int RenderThreadImpl::GetGpuRasterizationMSAASampleCount() {
   return gpu_rasterization_msaa_sample_count_;
@@ skipping 492 matching lines @@
 }
 
 void RenderThreadImpl::PendingRenderFrameConnect::OnConnectionError() {
   size_t erased =
       RenderThreadImpl::current()->pending_render_frame_connects_.erase(
           routing_id_);
   DCHECK_EQ(1u, erased);
 }
 
 }  // namespace content