cc: Remove things from OutputSurface and CompositorFrameSink.

content/renderer/android/synchronous_compositor_frame_sink.cc

 // Copyright 2013 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/android/synchronous_compositor_frame_sink.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 57 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 }  // namespace
 
 class SynchronousCompositorFrameSink::SoftwareOutputSurface
     : public cc::OutputSurface {
  public:
   SoftwareOutputSurface(std::unique_ptr<SoftwareDevice> software_device)
-      : cc::OutputSurface(nullptr, nullptr, std::move(software_device)) {}
+      : cc::OutputSurface(std::move(software_device)) {}
 
   // cc::OutputSurface implementation.
   uint32_t GetFramebufferCopyTextureFormat() override { return 0; }
   void SwapBuffers(cc::CompositorFrame frame) override {}
   void Reshape(const gfx::Size& size,
                float scale_factor,
                const gfx::ColorSpace& color_space,
                bool has_alpha) override {
     // Intentional no-op. Surface size controlled by embedder.
   }
 
   void SetSurfaceSize(const gfx::Size surface_size) {
     surface_size_ = surface_size;
   }
 };
 
 SynchronousCompositorFrameSink::SynchronousCompositorFrameSink(
     scoped_refptr<cc::ContextProvider> context_provider,
     scoped_refptr<cc::ContextProvider> worker_context_provider,
     int routing_id,
     uint32_t compositor_frame_sink_id,
     std::unique_ptr<cc::BeginFrameSource> begin_frame_source,
     SynchronousCompositorRegistry* registry,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::CompositorFrameSink(std::move(context_provider),
-                              std::move(worker_context_provider),
-                              nullptr),
+                              std::move(worker_context_provider)),
       routing_id_(routing_id),
       compositor_frame_sink_id_(compositor_frame_sink_id),
       registry_(registry),
       sender_(RenderThreadImpl::current()->sync_compositor_message_filter()),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue),
       surface_manager_(new cc::SurfaceManager),
       surface_id_allocator_(new cc::SurfaceIdAllocator(kCompositorClientId)),
       surface_factory_(new cc::SurfaceFactory(surface_manager_.get(), this)),
       begin_frame_source_(std::move(begin_frame_source)) {
   DCHECK(registry_);
   DCHECK(sender_);
   DCHECK(begin_frame_source_);
   thread_checker_.DetachFromThread();
-  capabilities_.adjust_deadline_for_parent = false;
-  capabilities_.delegated_rendering = true;
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
+  capabilities_.adjust_deadline_for_parent = false;
 }
 
 SynchronousCompositorFrameSink::~SynchronousCompositorFrameSink() = default;
 
 void SynchronousCompositorFrameSink::SetSyncClient(
     SynchronousCompositorFrameSinkClient* compositor) {
   DCHECK(CalledOnValidThread());
   sync_client_ = compositor;
   if (sync_client_)
     Send(new SyncCompositorHostMsg_CompositorFrameSinkCreated(routing_id_));
@@ skipping 67 matching lines @@
       surface_id_allocator_->client_id());
   software_compositor_frame_sink_ = nullptr;
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
-void SynchronousCompositorFrameSink::Reshape(const gfx::Size& size,
-                                             float scale_factor,
-                                             const gfx::ColorSpace& color_space,
-                                             bool has_alpha) {
-  // Intentional no-op: surface size is controlled by the embedder.
-}
-
 static void NoOpDrawCallback() {}
 
 void SynchronousCompositorFrameSink::SwapBuffers(cc::CompositorFrame frame) {
   DCHECK(CalledOnValidThread());
   DCHECK(sync_client_);
 
   if (fallback_tick_running_) {
     DCHECK(frame.delegated_frame_data->resource_list.empty());
     cc::ReturnedResourceArray return_resources;
     ReturnResources(return_resources);
@@ skipping 60 matching lines @@
     fallback_tick_.Reset(
         base::Bind(&SynchronousCompositorFrameSink::FallbackTickFired,
                    base::Unretained(this)));
     base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
         FROM_HERE, fallback_tick_.callback(),
         base::TimeDelta::FromMilliseconds(kFallbackTickTimeoutInMilliseconds));
     fallback_tick_pending_ = true;
   }
 }
 
-void SynchronousCompositorFrameSink::BindFramebuffer() {
-  // This is a delegating output surface, no framebuffer/direct drawing support.
-  NOTREACHED();
-}
-
-uint32_t SynchronousCompositorFrameSink::GetFramebufferCopyTextureFormat() {
-  // This is a delegating output surface, no framebuffer/direct drawing support.
-  NOTREACHED();
-  return 0;
-}
-
 void SynchronousCompositorFrameSink::DemandDrawHw(
     const gfx::Size& viewport_size,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(context_provider_.get());
   CancelFallbackTick();
 
   client_->SetExternalTilePriorityConstraints(viewport_rect_for_tile_priority,
@@ skipping 104 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorFrameSink::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content