Revert of cc: Delete all the RendererCapabilities.

cc/trees/proxy_main.cc

 // Copyright 2015 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/proxy_main.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/trace_event/trace_event.h"
@@ skipping 58 matching lines @@
 void ProxyMain::SetChannel(std::unique_ptr<ChannelMain> channel_main) {
   DCHECK(!channel_main_);
   channel_main_ = std::move(channel_main);
 }
 
 void ProxyMain::DidCompleteSwapBuffers() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCompleteSwapBuffers();
 }
 
+void ProxyMain::SetRendererCapabilities(
+    const RendererCapabilities& capabilities) {
+  DCHECK(IsMainThread());
+  renderer_capabilities_ = capabilities;
+}
+
 void ProxyMain::BeginMainFrameNotExpectedSoon() {
   TRACE_EVENT0("cc", "ProxyMain::BeginMainFrameNotExpectedSoon");
   DCHECK(IsMainThread());
   layer_tree_host_->BeginMainFrameNotExpectedSoon();
 }
 
 void ProxyMain::DidCommitAndDrawFrame() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCommitAndDrawFrame();
 }
 
 void ProxyMain::SetAnimationEvents(std::unique_ptr<AnimationEvents> events) {
   TRACE_EVENT0("cc", "ProxyMain::SetAnimationEvents");
   DCHECK(IsMainThread());
   layer_tree_host_->SetAnimationEvents(std::move(events));
 }
 
 void ProxyMain::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "ProxyMain::DidLoseOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host_->DidLoseOutputSurface();
 }
 
 void ProxyMain::RequestNewOutputSurface() {
   TRACE_EVENT0("cc", "ProxyMain::RequestNewOutputSurface");
   DCHECK(IsMainThread());
   layer_tree_host_->RequestNewOutputSurface();
 }
 
-void ProxyMain::DidInitializeOutputSurface(bool success) {
+void ProxyMain::DidInitializeOutputSurface(
+    bool success,
+    const RendererCapabilities& capabilities) {
   TRACE_EVENT0("cc", "ProxyMain::DidInitializeOutputSurface");
   DCHECK(IsMainThread());
 
-  if (!success)
+  if (!success) {
     layer_tree_host_->DidFailToInitializeOutputSurface();
-  else
-    layer_tree_host_->DidInitializeOutputSurface();
+    return;
+  }
+  renderer_capabilities_ = capabilities;
+  layer_tree_host_->DidInitializeOutputSurface();
 }
 
 void ProxyMain::DidCompletePageScaleAnimation() {
   DCHECK(IsMainThread());
   layer_tree_host_->DidCompletePageScaleAnimation();
 }
 
 void ProxyMain::BeginMainFrame(
     std::unique_ptr<BeginMainFrameAndCommitState> begin_main_frame_state) {
   benchmark_instrumentation::ScopedBeginFrameTask begin_frame_task(
@@ skipping 137 matching lines @@
 
 void ProxyMain::SetOutputSurface(OutputSurface* output_surface) {
   channel_main_->InitializeOutputSurfaceOnImpl(output_surface);
 }
 
 void ProxyMain::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "ProxyMain::SetVisible", "visible", visible);
   channel_main_->SetVisibleOnImpl(visible);
 }
 
+const RendererCapabilities& ProxyMain::GetRendererCapabilities() const {
+  DCHECK(IsMainThread());
+  DCHECK(!layer_tree_host_->output_surface_lost());
+  return renderer_capabilities_;
+}
+
 void ProxyMain::SetNeedsAnimate() {
   DCHECK(IsMainThread());
   if (SendCommitRequestToImplThreadIfNeeded(ANIMATE_PIPELINE_STAGE)) {
     TRACE_EVENT_INSTANT0("cc", "ProxyMain::SetNeedsAnimate",
                          TRACE_EVENT_SCOPE_THREAD);
   }
 }
 
 void ProxyMain::SetNeedsUpdateLayers() {
   DCHECK(IsMainThread());
@@ skipping 149 matching lines @@
     return false;
   channel_main_->SetNeedsCommitOnImpl();
   return true;
 }
 
 bool ProxyMain::IsMainThread() const {
   return task_runner_provider_->IsMainThread();
 }
 
 }  // namespace cc