cc: Remove all impl-side caps from RendererCapabilitiesImpl.

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 210 matching lines @@
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     std::unique_ptr<AnimationHost> animation_host,
     int id)
     : client_(client),
       task_runner_provider_(task_runner_provider),
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       output_surface_(nullptr),
+      need_update_gpu_rasterization_status_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
-      tree_resources_for_gpu_rasterization_dirty_(false),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(Layer::INVALID_ID),
       tile_priorities_dirty_(false),
       settings_(settings),
       visible_(false),
       cached_managed_memory_policy_(settings.memory_policy_),
       is_synchronous_single_threaded_(!task_runner_provider->HasImplThread() &&
@@ skipping 1506 matching lines @@
     // Use the most up-to-date version of device_scale_factor that we have.
     float device_scale_factor = pending_tree_
                                     ? pending_tree_->device_scale_factor()
                                     : active_tree_->device_scale_factor();
     return device_scale_factor >= 2.0f ? 4 : 8;
   }
 
   return settings_.gpu_rasterization_msaa_sample_count;
 }
 
+void LayerTreeHostImpl::SetHasGpuRasterizationTrigger(bool flag) {
+  if (has_gpu_rasterization_trigger_ != flag) {
+    has_gpu_rasterization_trigger_ = flag;
+    need_update_gpu_rasterization_status_ = true;
+  }
+}
+
+void LayerTreeHostImpl::SetContentIsSuitableForGpuRasterization(bool flag) {
+  if (content_is_suitable_for_gpu_rasterization_ != flag) {
+    content_is_suitable_for_gpu_rasterization_ = flag;
+    need_update_gpu_rasterization_status_ = true;
+  }
+}
+
 bool LayerTreeHostImpl::CanUseGpuRasterization() {
   if (!(output_surface_ && output_surface_->context_provider() &&
         output_surface_->worker_context_provider()))
     return false;
 
   ContextProvider* context_provider =
       output_surface_->worker_context_provider();
   ContextProvider::ScopedContextLock scoped_context(context_provider);
   if (!context_provider->GrContext())
     return false;
 
   return true;
 }
 
-void LayerTreeHostImpl::UpdateGpuRasterizationStatus() {
+bool LayerTreeHostImpl::UpdateGpuRasterizationStatus() {
+  // TODO(danakj): Can we avoid having this run when there's no output surface?
+  // For now just early out and leave things unchanged, we'll come back here
+  // when we get an output surface.
+  if (!output_surface_)
+    return false;
+
+  int requested_msaa_samples = RequestedMSAASampleCount();
+  int max_msaa_samples = 0;
+  ContextProvider* compositor_context_provider =
+      output_surface_->context_provider();
+  if (compositor_context_provider) {
+    const auto& caps = compositor_context_provider->ContextCapabilities();
+    if (!caps.msaa_is_slow)
+      max_msaa_samples = caps.max_samples;
+  }
+
   bool use_gpu = false;
   bool use_msaa = false;
   bool using_msaa_for_complex_content =
-      renderer() && RequestedMSAASampleCount() > 0 &&
-      GetRendererCapabilities().max_msaa_samples >= RequestedMSAASampleCount();
+      requested_msaa_samples > 0 && max_msaa_samples >= requested_msaa_samples;
   if (settings_.gpu_rasterization_forced) {
     use_gpu = true;
     gpu_rasterization_status_ = GpuRasterizationStatus::ON_FORCED;
     use_msaa = !content_is_suitable_for_gpu_rasterization_ &&
                using_msaa_for_complex_content;
     if (use_msaa) {
       gpu_rasterization_status_ = GpuRasterizationStatus::MSAA_CONTENT;
     }
   } else if (!settings_.gpu_rasterization_enabled) {
     gpu_rasterization_status_ = GpuRasterizationStatus::OFF_DEVICE;
@@ skipping 14 matching lines @@
       // If GPU rasterization is unusable, e.g. if GlContext could not
       // be created due to losing the GL context, force use of software
       // raster.
       use_gpu = false;
       use_msaa = false;
       gpu_rasterization_status_ = GpuRasterizationStatus::OFF_DEVICE;
     }
   }
 
   if (use_gpu == use_gpu_rasterization_ && use_msaa == use_msaa_)
-    return;
+    return false;
 
   // Note that this must happen first, in case the rest of the calls want to
   // query the new state of |use_gpu_rasterization_|.
   use_gpu_rasterization_ = use_gpu;
   use_msaa_ = use_msaa;
-
-  tree_resources_for_gpu_rasterization_dirty_ = true;
+  return true;
 }
 
 void LayerTreeHostImpl::UpdateTreeResourcesForGpuRasterizationIfNeeded() {
-  if (!tree_resources_for_gpu_rasterization_dirty_)
+  if (!need_update_gpu_rasterization_status_)
+    return;
+  if (!UpdateGpuRasterizationStatus())
     return;
 
   // Clean up and replace existing tile manager with another one that uses
   // appropriate rasterizer. Only do this however if we already have a
   // resource pool, since otherwise we might not be able to create a new
   // one.
   ReleaseTreeResources();
   if (resource_pool_) {
     CleanUpTileManagerAndUIResources();
     CreateTileManagerResources();
   }
   RecreateTreeResources();
 
   // We have released tilings for both active and pending tree.
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
   // TODO(crbug.com/469175): Replace with RequiresHighResToDraw.
   SetRequiresHighResToDraw();
-
-  tree_resources_for_gpu_rasterization_dirty_ = false;
 }
 
 const RendererCapabilitiesImpl& LayerTreeHostImpl::GetRendererCapabilities()
     const {
   CHECK(renderer_);
   return renderer_->Capabilities();
 }
 
 bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
   ResetRequiresHighResToDraw();
@@ skipping 375 matching lines @@
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
     *raster_buffer_provider = base::MakeUnique<GpuRasterBufferProvider>(
         compositor_context_provider, worker_context_provider,
         resource_provider_.get(), settings_.use_distance_field_text,
         msaa_sample_count, settings_.async_worker_context_enabled);
     return;
   }
 
-  DCHECK(GetRendererCapabilities().using_image);
+  DCHECK(compositor_context_provider->ContextCapabilities().image);
 
   bool use_zero_copy = settings_.use_zero_copy;
   // TODO(reveman): Remove this when mojo supports worker contexts.
   // crbug.com/522440
   if (!use_zero_copy && !worker_context_provider) {
     LOG(ERROR)
         << "Forcing zero-copy tile initialization as worker context is missing";
     use_zero_copy = true;
   }
 
@@ skipping 83 matching lines @@
   resource_provider_ = base::MakeUnique<ResourceProvider>(
       output_surface_->context_provider(), shared_bitmap_manager_,
       gpu_memory_buffer_manager_,
       task_runner_provider_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.renderer_settings.use_gpu_memory_buffer_resources,
       settings_.renderer_settings.buffer_to_texture_target_map);
 
+  // Since the new context may be capable of MSAA, update status here. We don't
+  // need to check the return value since we are recreating all resources
+  // already.
+  UpdateGpuRasterizationStatus();
+
   CreateAndSetRenderer();
 
-  // Since the new renderer may be capable of MSAA, update status here.
-  UpdateGpuRasterizationStatus();
-
   CreateTileManagerResources();
   RecreateTreeResources();
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
           base::Time::kMicrosecondsPerSecond /
           settings_.renderer_settings.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
@@ skipping 1695 matching lines @@
   return task_runner_provider_->HasImplThread();
 }
 
 bool LayerTreeHostImpl::CommitToActiveTree() const {
   // In single threaded mode we skip the pending tree and commit directly to the
   // active tree.
   return !task_runner_provider_->HasImplThread();
 }
 
 }  // namespace cc