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),
@@ skipping 51 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 101 matching lines @@
     const gfx::Transform& transform,
     const gfx::Rect& viewport,
     const gfx::Rect& clip,
     const gfx::Rect& viewport_rect_for_tile_priority,
     const gfx::Transform& transform_for_tile_priority) {
   DCHECK(CalledOnValidThread());
   DCHECK(HasClient());
   DCHECK(context_provider_.get());
   CancelFallbackTick();
 
-  surface_size_ = surface_size;
   client_->SetExternalTilePriorityConstraints(viewport_rect_for_tile_priority,
                                               transform_for_tile_priority);
   InvokeComposite(transform, viewport, clip);
 }
 
 void SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
   CancelFallbackTick();
 
   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(),
-                            canvas->getBaseLayerSize().height());
   base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true);
+  display_->SetExternalViewport(clip);
+  display_->SetExternalClip(clip);
+  gfx::Size surface_size(canvas->getBaseLayerSize().width(),

[danakj, 2016/07/27 22:18:03]

nit: You could do
s_o_s_->SetSurfaceSize(gfx::SkISizeToSize(canvas->getBaseLayerSize()));

[boliu, 2016/07/27 22:22:50]

Done.

+                         canvas->getBaseLayerSize().height());
+  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