sync compositor: Set display viewport for software draw

content/renderer/android/synchronous_compositor_output_surface.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_output_surface.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/location.h"
@@ skipping 31 matching lines @@
 namespace content {
 
 namespace {
 
 const int64_t kFallbackTickTimeoutInMilliseconds = 100;
 const uint32_t kCompositorClientId = 1;
 
 // Do not limit number of resources, so use an unrealistically high value.
 const size_t kNumResourcesLimit = 10 * 1000 * 1000;
 
-}  // namespace
-
 class SoftwareDevice : public cc::SoftwareOutputDevice {
  public:
   SoftwareDevice(SkCanvas** canvas) : canvas_(canvas) {}
 
   void Resize(const gfx::Size& pixel_size, float scale_factor) override {
     // Intentional no-op: canvas size is controlled by the embedder.
   }
   SkCanvas* BeginPaint(const gfx::Rect& damage_rect) override {
     DCHECK(*canvas_) << "BeginPaint with no canvas set";
     return *canvas_;
   }
   void EndPaint() override {}
 
  private:
   SkCanvas** canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
-class SoftwareOutputSurface : public cc::OutputSurface {
+}  // namespace
+
+class SynchronousCompositorOutputSurface::SoftwareOutputSurface
+    : public cc::OutputSurface {
  public:
   SoftwareOutputSurface(std::unique_ptr<SoftwareDevice> software_device)
       : cc::OutputSurface(nullptr, nullptr, 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;
+  }
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
     scoped_refptr<cc::ContextProvider> context_provider,
     scoped_refptr<cc::ContextProvider> worker_context_provider,
     int routing_id,
     uint32_t output_surface_id,
     SynchronousCompositorRegistry* registry,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::OutputSurface(std::move(context_provider),
                         std::move(worker_context_provider),
                         nullptr),
       routing_id_(routing_id),
       output_surface_id_(output_surface_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)) {
+      surface_factory_(new cc::SurfaceFactory(surface_manager_.get(), this)),
+      software_output_surface_(nullptr) {
   DCHECK(registry_);
   DCHECK(sender_);
   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;
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() =
@@ skipping 30 matching lines @@
                  base::Unretained(this)));
   registry_->RegisterOutputSurface(routing_id_, this);
   registered_ = true;
 
   surface_manager_->RegisterSurfaceClientId(surface_id_allocator_->client_id());
   surface_manager_->RegisterSurfaceFactoryClient(
       surface_id_allocator_->client_id(), this);
 
   cc::RendererSettings software_renderer_settings;
 
+  std::unique_ptr<SoftwareOutputSurface> output_surface(
+      new SoftwareOutputSurface(
+          base::MakeUnique<SoftwareDevice>(&current_sw_canvas_)));
+  software_output_surface_ = output_surface.get();
+
   // The shared_bitmap_manager and gpu_memory_buffer_manager here are null as
   // this Display is only used for resourcesless software draws, where no
   // resources are included in the frame swapped from the compositor. So there
   // is no need for these.
   display_.reset(new cc::Display(
       nullptr /* shared_bitmap_manager */,
       nullptr /* gpu_memory_buffer_manager */, software_renderer_settings,
-      nullptr /* begin_frame_source */,
-      base::MakeUnique<SoftwareOutputSurface>(
-          base::MakeUnique<SoftwareDevice>(&current_sw_canvas_)),
+      nullptr /* begin_frame_source */, std::move(output_surface),
       nullptr /* scheduler */, nullptr /* texture_mailbox_deleter */));
   display_->Initialize(&display_client_, surface_manager_.get(),
                        surface_id_allocator_->client_id());
   return true;
 }
 
 void SynchronousCompositorOutputSurface::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   if (registered_) {
     registry_->UnregisterOutputSurface(routing_id_, this);
   }
   client_->SetTreeActivationCallback(base::Closure());
   if (!delegated_surface_id_.is_null())
     surface_factory_->Destroy(delegated_surface_id_);
   surface_manager_->UnregisterSurfaceFactoryClient(
       surface_id_allocator_->client_id());
   surface_manager_->InvalidateSurfaceClientId(
       surface_id_allocator_->client_id());
+  software_output_surface_ = nullptr;
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::OutputSurface::DetachFromClient();
   CancelFallbackTick();
 }
 
 void SynchronousCompositorOutputSurface::Reshape(
     const gfx::Size& size,
@@ skipping 122 matching lines @@
 
   base::AutoReset<SkCanvas*> canvas_resetter(&current_sw_canvas_, canvas);
 
   SkIRect canvas_clip;
   canvas->getClipDeviceBounds(&canvas_clip);
   gfx::Rect clip = gfx::SkIRectToRect(canvas_clip);
 
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix() = canvas->getTotalMatrix();  // Converts 3x3 matrix to 4x4.
 
   surface_size_ = gfx::Size(canvas->getBaseLayerSize().width(),

[danakj, 2016/07/27 21:28:36]

Ahh. Does it need to be a member on SCOS still too or can it be a local var
here?

[boliu, 2016/07/27 21:43:04]

Hmm... in practice, no, because DelegatingRenderer doesn't use this at all, so
don't need to set it in DemandDrawHw either.

But if only remove it here, then it makes no sense for SCOS to have the surface
size from hardware draw, even if it's not used.

Long term, it would be good to like have cc::Display use a separate
OutputSurface type, and only have all this resize logic on that type.

In this CL? Umm, keep it just to be consistent with everything else?

[danakj, 2016/07/27 21:49:53]

I'm working toward that right now.
If you make it different now with comments it'll make it easier for me to split
the two APIs apart and understand what needs to be on the LTHI's API vs the
Display's API. Or at least put some TODOs/comments explaining. But I'd prefer to
not set things that won't be used.

[boliu, 2016/07/27 22:00:51]

Ok, not setting SCOS::surface_size_ anywhere, and it will remain empty. That's
consistent too :p

                             canvas->getBaseLayerSize().height());
   base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true);
+  display_->SetExternalViewport(clip);
+  display_->SetExternalClip(clip);
+  software_output_surface_->SetSurfaceSize(surface_size_);
   InvokeComposite(transform, clip, clip);
 }
 
 void SynchronousCompositorOutputSurface::InvokeComposite(
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip) {
   gfx::Transform adjusted_transform = transform;
   adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
   did_swap_ = false;
@@ skipping 71 matching lines @@
   client_->ReclaimResources(resources);
 }
 
 void SynchronousCompositorOutputSurface::SetBeginFrameSource(
     cc::BeginFrameSource* begin_frame_source) {
   // Software output is synchronous and doesn't use a BeginFrameSource.
   NOTREACHED();
 }
 
 }  // namespace content