Revert of cc: Delete all the RendererCapabilities.

cc/trees/single_thread_proxy.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/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 134 matching lines @@
 
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidLoseOutputSurface();
   return layer_tree_host_impl_->ReleaseOutputSurface();
 }
 
 void SingleThreadProxy::SetOutputSurface(OutputSurface* output_surface) {
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(layer_tree_host_->output_surface_lost());
   DCHECK(output_surface_creation_requested_);
+  renderer_capabilities_for_main_thread_ = RendererCapabilities();
 
   bool success;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
     DebugScopedSetImplThread impl(task_runner_provider_);
     success = layer_tree_host_impl_->InitializeRenderer(output_surface);
   }
 
   if (success) {
     layer_tree_host_->DidInitializeOutputSurface();
     if (scheduler_on_impl_thread_)
       scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
     else if (!inside_synchronous_composite_)
       SetNeedsCommit();
     output_surface_creation_requested_ = false;
   } else {
     // DidFailToInitializeOutputSurface is treated as a RequestNewOutputSurface,
     // and so output_surface_creation_requested remains true.
     layer_tree_host_->DidFailToInitializeOutputSurface();
   }
 }
 
+const RendererCapabilities& SingleThreadProxy::GetRendererCapabilities() const {
+  DCHECK(task_runner_provider_->IsMainThread());
+  DCHECK(!layer_tree_host_->output_surface_lost());
+  return renderer_capabilities_for_main_thread_;
+}
+
 void SingleThreadProxy::SetNeedsAnimate() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate");
   DCHECK(task_runner_provider_->IsMainThread());
   client_->RequestScheduleAnimation();
   if (animate_requested_)
     return;
   animate_requested_ = true;
   DebugScopedSetImplThread impl(task_runner_provider_);
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetNeedsBeginMainFrame();
@@ skipping 256 matching lines @@
 void SingleThreadProxy::DidPrepareTiles() {
   DCHECK(task_runner_provider_->IsImplThread());
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidPrepareTiles();
 }
 
 void SingleThreadProxy::DidCompletePageScaleAnimationOnImplThread() {
   layer_tree_host_->DidCompletePageScaleAnimation();
 }
 
+void SingleThreadProxy::UpdateRendererCapabilitiesOnImplThread() {
+  DCHECK(task_runner_provider_->IsImplThread());
+  renderer_capabilities_for_main_thread_ =
+      layer_tree_host_impl_->GetRendererCapabilities().MainThreadCapabilities();
+}
+
 void SingleThreadProxy::DidLoseOutputSurfaceOnImplThread() {
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
   {
     DebugScopedSetMainThread main(task_runner_provider_);
     // This must happen before we notify the scheduler as it may try to recreate
     // the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE.
     layer_tree_host_->DidLoseOutputSurface();
   }
   client_->DidAbortSwapBuffers();
   if (scheduler_on_impl_thread_)
@@ skipping 400 matching lines @@
 void SingleThreadProxy::DidFinishImplFrame() {
   layer_tree_host_impl_->DidFinishImplFrame();
 #if DCHECK_IS_ON()
   DCHECK(inside_impl_frame_)
       << "DidFinishImplFrame called while not inside an impl frame!";
   inside_impl_frame_ = false;
 #endif
 }
 
 }  // namespace cc