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 155 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 57 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.
 
+  // 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());
+
   base::AutoReset<bool> set_in_software_draw(&in_software_draw_, true);
-  display_->SetExternalViewport(viewport);
-  display_->SetExternalClip(viewport);

[boliu, 2016/09/27 23:20:48]

keep external clip

apparently the assumption that display will respect the clip already in the
canvas isn't cornrect :p

[danakj, 2016/09/29 22:55:52]

Done.

-  software_compositor_frame_sink_->SetSurfaceSize(
+  software_output_surface_->SetSurfaceSize(
       gfx::SkISizeToSize(canvas->getBaseLayerSize()));

[danakj, 2016/09/29 22:55:52]

I also removed this call, and made Reshape() store the size given to it, which
will be the size of the rect computed above since that is what we give to
Display::Resize

   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);

[boliu, 2016/09/27 23:20:48]

drop this "adjustment"

the matrix contains translate, so this undoes that translate, so apparently old
code always had renderer compositor think it's drawing at 0,0, but at a
different viewport rect, if that makes sense...

and hardware draw path doesn't need this at all, ie x,y are always both 0

[danakj, 2016/09/29 22:55:52]

Done.

   did_swap_ = false;
   client_->OnDraw(adjusted_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();
   }
 }
@@ skipping 62 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