cc: Introduce CompositorMode enum.

cc/trees/layer_tree_host.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
 #include <stack>
 #include <string>
 
@@ skipping 48 matching lines @@
 
 LayerTreeHost::InitParams::~InitParams() {
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
   DCHECK(params->settings);
-  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
+  scoped_ptr<LayerTreeHost> layer_tree_host(
+      new LayerTreeHost(params, CompositorMode::Threaded));
   layer_tree_host->InitializeThreaded(
       params->main_task_runner, impl_task_runner,
       std::move(params->external_begin_frame_source));
   return layer_tree_host;
 }
 
 scoped_ptr<LayerTreeHost> LayerTreeHost::CreateSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     InitParams* params) {
   DCHECK(params->settings);
-  scoped_ptr<LayerTreeHost> layer_tree_host(new LayerTreeHost(params));
+  scoped_ptr<LayerTreeHost> layer_tree_host(
+      new LayerTreeHost(params, CompositorMode::SingleThreaded));
   layer_tree_host->InitializeSingleThreaded(
       single_thread_client, params->main_task_runner,
       std::move(params->external_begin_frame_source));
   return layer_tree_host;
 }
 
-LayerTreeHost::LayerTreeHost(InitParams* params)
+LayerTreeHost::LayerTreeHost(InitParams* params, CompositorMode mode)
     : micro_benchmark_controller_(this),
       next_ui_resource_id_(1),
+      compositor_mode_(mode),
       needs_full_tree_sync_(true),
       needs_meta_info_recomputation_(true),
       client_(params->client),
       source_frame_number_(0),
       meta_information_sequence_number_(1),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
       output_surface_lost_(true),
       settings_(*params->settings),
       debug_state_(settings_.initial_debug_state),
       top_controls_shrink_blink_size_(false),
@@ skipping 567 matching lines @@
           duration));
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
 void LayerTreeHost::LayoutAndUpdateLayers() {
-  DCHECK(!task_runner_provider_->HasImplThread());
+  DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   if (output_surface_lost()) {
     proxy->RequestNewOutputSurface();
     // RequestNewOutputSurface could have synchronously created an output
     // surface, so check again before returning.
     if (output_surface_lost())
       return;
   }
 
   RequestMainFrameUpdate();
   UpdateLayers();
 }
 
 void LayerTreeHost::Composite(base::TimeTicks frame_begin_time) {
-  DCHECK(!task_runner_provider_->HasImplThread());
+  DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   proxy->CompositeImmediately(frame_begin_time);
 }
 
 bool LayerTreeHost::UpdateLayers() {
   DCHECK(!output_surface_lost_);
   if (!root_layer())
@@ skipping 19 matching lines @@
     Layer* found = FindFirstScrollableLayer(layer->children()[i].get());
     if (found)
       return found;
   }
 
   return NULL;
 }
 
 void LayerTreeHost::RecordGpuRasterizationHistogram() {
   // Gpu rasterization is only supported for Renderer compositors.
-  // Checking for proxy_->HasImplThread() to exclude Browser compositors.
-  if (gpu_rasterization_histogram_recorded_ ||
-      !task_runner_provider_->HasImplThread())
+  // Checking for IsThreaded() to exclude Browser compositors.
+  if (gpu_rasterization_histogram_recorded_ || IsThreaded())
     return;
 
   // Record how widely gpu rasterization is enabled.
   // This number takes device/gpu whitelisting/backlisting into account.
   // Note that we do not consider the forced gpu rasterization mode, which is
   // mostly used for debugging purposes.
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationEnabled",
                         settings_.gpu_rasterization_enabled);
   if (settings_.gpu_rasterization_enabled) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationTriggered",
@@ skipping 145 matching lines @@
     return;
   painted_device_scale_factor_ = painted_device_scale_factor;
 
   SetNeedsCommit();
 }
 
 void LayerTreeHost::UpdateTopControlsState(TopControlsState constraints,
                                            TopControlsState current,
                                            bool animate) {
   // Top controls are only used in threaded mode.
-  DCHECK(task_runner_provider_->HasImplThread());
+  DCHECK(IsThreaded());
   proxy_->UpdateTopControlsState(constraints, current, animate);
 }
 
 void LayerTreeHost::AnimateLayers(base::TimeTicks monotonic_time) {
   if (!settings_.accelerated_animation_enabled)
     return;
 
   AnimationEventsVector events;
   if (animation_host_) {
     if (animation_host_->AnimateLayers(monotonic_time))
@@ skipping 330 matching lines @@
 bool LayerTreeHost::HasAnyAnimation(const Layer* layer) const {
   return animation_host_ ? animation_host_->HasAnyAnimation(layer->id())
                          : false;
 }
 
 bool LayerTreeHost::HasActiveAnimation(const Layer* layer) const {
   return animation_host_ ? animation_host_->HasActiveAnimation(layer->id())
                          : false;
 }
 
+bool LayerTreeHost::IsSingleThreaded() const {
+  DCHECK(compositor_mode_ != CompositorMode::SingleThreaded ||
+         !task_runner_provider_->HasImplThread());
+  return compositor_mode_ == CompositorMode::SingleThreaded;
+}
+
+bool LayerTreeHost::IsThreaded() const {
+  DCHECK(compositor_mode_ != CompositorMode::Threaded ||
+         task_runner_provider_->HasImplThread());
+  return compositor_mode_ == CompositorMode::Threaded;
+}
+
 }  // namespace cc