cc: Remove Display::SetExternalViewport.

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 68 matching lines @@
 
   // cc::OutputSurface implementation.
   void EnsureBackbuffer() override {}
   void DiscardBackbuffer() override {}
   void BindFramebuffer() override {}
   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.
+    surface_size_ = size;
   }
   uint32_t GetFramebufferCopyTextureFormat() override { return 0; }
   cc::OverlayCandidateValidator* GetOverlayCandidateValidator() const override {
     return nullptr;
   }
   bool IsDisplayedAsOverlayPlane() const override { return false; }
   unsigned GetOverlayTextureId() const override { return 0; }
   bool SurfaceIsSuspendForRecycle() const override { return false; }
   bool HasExternalStencilTest() const override { return false; }
   void ApplyExternalStencil() override {}
-
-  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)
@@ skipping 52 matching lines @@
                  base::Unretained(this)));
   registry_->RegisterCompositorFrameSink(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> compositor_frame_sink(
-      new SoftwareOutputSurface(
-          base::MakeUnique<SoftwareDevice>(&current_sw_canvas_)));
-  software_compositor_frame_sink_ = compositor_frame_sink.get();
+  auto output_surface = base::MakeUnique<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 */, std::move(compositor_frame_sink),
+      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());
   display_->SetVisible(true);
   return true;
 }
 
 void SynchronousCompositorFrameSink::DetachFromClient() {
   DCHECK(CalledOnValidThread());
   client_->SetBeginFrameSource(nullptr);
   // Destroy the begin frame source on the same thread it was bound on.
   begin_frame_source_ = nullptr;
   if (registered_)
     registry_->UnregisterCompositorFrameSink(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_compositor_frame_sink_ = nullptr;
+  software_output_surface_ = nullptr;
   display_ = nullptr;
   surface_factory_ = nullptr;
   surface_id_allocator_ = nullptr;
   surface_manager_ = nullptr;
   cc::CompositorFrameSink::DetachFromClient();
   CancelFallbackTick();
 }
 
 static void NoOpDrawCallback() {}
 
@@ skipping 17 matching lines @@
     swap_frame.metadata = frame.metadata.Clone();
 
     if (delegated_surface_id_.is_null()) {
       delegated_surface_id_ = surface_id_allocator_->GenerateId();
       surface_factory_->Create(delegated_surface_id_);
     }
 
     display_->SetSurfaceId(delegated_surface_id_,
                            frame.metadata.device_scale_factor);
 
-    gfx::Size frame_size =
-        frame.delegated_frame_data->render_pass_list.back()->output_rect.size();
-    display_->Resize(frame_size);
+    // This size covers the entire external clip given to DemandDrawSw(). The
+    // CompositorFrame here could be either smaller than this size (we're
+    // drawing an enlarged viewport that extends beyond the layer compositor's
+    // concept of the output size) or larger than this size (we're only drawing
+    // a portion of the layer compositor's usual output size).
+    display_->Resize(sw_display_size_for_current_draw_);
 
     surface_factory_->SubmitCompositorFrame(
         delegated_surface_id_, std::move(frame), base::Bind(&NoOpDrawCallback));
     display_->DrawAndSwap();
   } else {
     // For hardware draws we send the whole frame to the client so it can draw
     // the content in it.
     swap_frame = std::move(frame);
   }
 
@@ skipping 58 matching lines @@
   base::AutoReset<SkCanvas*> canvas_resetter(&current_sw_canvas_, canvas);
 
   SkIRect canvas_clip;
   canvas->getClipDeviceBounds(&canvas_clip);
   gfx::Rect viewport = gfx::SkIRectToRect(canvas_clip);
 
   gfx::Transform transform(gfx::Transform::kSkipInitialization);
   transform.matrix() = canvas->getTotalMatrix();  // Converts 3x3 matrix to 4x4.
 
   base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true);
-  display_->SetExternalViewport(viewport);
+
+  // We will resize the Display to ensure it draws the entire |viewport| given
+  // here instead of only the layer compositor's idea of what the viewport is.
+  sw_display_size_for_current_draw_ =
+      gfx::Size(viewport.right(), viewport.bottom());
+  // Though the canvas already has a clip on it the Display can destroy it so we
+  // need to tell it about the clip.
   display_->SetExternalClip(viewport);
-  software_compositor_frame_sink_->SetSurfaceSize(
-      gfx::SkISizeToSize(canvas->getBaseLayerSize()));
   InvokeComposite(transform, viewport);
 }
 
 void SynchronousCompositorFrameSink::InvokeComposite(
     const gfx::Transform& transform,
     const gfx::Rect& viewport) {
-  gfx::Transform adjusted_transform = transform;
-  adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
   did_swap_ = false;
-  client_->OnDraw(adjusted_transform, viewport, in_software_draw_);

[danakj, 2016/09/30 18:58:24]

Or it's probably related to this change..

[danakj, 2016/09/30 19:10:23]

So LTHI::UpdateDrawProperties would use this transform to figure out where to
draw things. You said it includes the viewport shift. So before what would
happen..

Say your viewport is 5,5,100,100. And you're drawing a dot at 10,10.

The transform would be +5,+5. We would adjust it by the viewport to make it
identity. Now LTHI draws with identity putting the dot at 10,10 and clipping
around 5,5,100,100. So its world origin is at 0,0 in the canvas.

After this change, the transform stays +5,+5. So we draw the dot at 15,15. But
we're clipping 5,5,100,100, so bad things occur and we clip the bottom 5px in
LTHI.


I'm trying to explain to myself the relationship of the Display tho now that
it's viewport origin is 0,0 instead of 5,5.

+  client_->OnDraw(transform, viewport, in_software_draw_);
 
   if (did_swap_) {
     // This must happen after unwinding the stack and leaving the compositor.
     // Usually it is a separate task but we just defer it until OnDraw completes
     // instead.
     client_->DidSwapBuffersComplete();
   }
 }
 
 void SynchronousCompositorFrameSink::OnReclaimResources(
@@ skipping 60 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