cc: Move draw params from SetExternalDrawConstraints to OnDraw

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 "base/auto_reset.h"
 #include "base/logging.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/context_provider.h"
@@ skipping 53 matching lines @@
     SynchronousCompositorRegistry* registry,
     scoped_refptr<FrameSwapMessageQueue> frame_swap_message_queue)
     : cc::OutputSurface(
           context_provider,
           worker_context_provider,
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
       registry_(registry),
       registered_(false),
       sync_client_(nullptr),
-      next_hardware_draw_needs_damage_(false),
       current_sw_canvas_(nullptr),
       memory_policy_(0u),
       frame_swap_message_queue_(frame_swap_message_queue) {
   thread_checker_.DetachFromThread();
   DCHECK(registry_);
   capabilities_.adjust_deadline_for_parent = false;
   capabilities_.delegated_rendering = true;
   memory_policy_.priority_cutoff_when_visible =
       gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE;
 }
@@ skipping 51 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());
 
   surface_size_ = surface_size;
-  InvokeComposite(transform, viewport, clip, viewport_rect_for_tile_priority,
-                  transform_for_tile_priority, true);
+  client_->SetExternalTilePriorityConstraints(viewport_rect_for_tile_priority,
+                                              transform_for_tile_priority);
+  const bool software_draw = false;
+  InvokeComposite(transform, viewport, clip, software_draw);
 
   return frame_holder_.Pass();
 }
 
 scoped_ptr<cc::CompositorFrame>
 SynchronousCompositorOutputSurface::DemandDrawSw(SkCanvas* canvas) {
   DCHECK(CalledOnValidThread());
   DCHECK(canvas);
   DCHECK(!current_sw_canvas_);
 
   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());
-
-  // Pass in the cached hw viewport and transform for tile priority to avoid
-  // tile thrashing when the WebView is alternating between hardware and
-  // software draws.
-  InvokeComposite(transform,
-                  clip,
-                  clip,
-                  cached_hw_viewport_rect_for_tile_priority_,
-                  cached_hw_transform_for_tile_priority_,
-                  false);
+  const bool software_draw = true;
+  InvokeComposite(transform, clip, clip, software_draw);
 
   return frame_holder_.Pass();
 }
 
 void SynchronousCompositorOutputSurface::InvokeComposite(
     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,
-    bool hardware_draw) {
+    bool software_draw) {
   DCHECK(!frame_holder_.get());
 
   gfx::Transform adjusted_transform = transform;
   adjusted_transform.matrix().postTranslate(-viewport.x(), -viewport.y(), 0);
-  SetExternalDrawConstraints(adjusted_transform, viewport, clip,
-                             viewport_rect_for_tile_priority,
-                             transform_for_tile_priority, !hardware_draw);
-  if (!hardware_draw || next_hardware_draw_needs_damage_) {
-    next_hardware_draw_needs_damage_ = false;
-    SetNeedsRedrawRect(gfx::Rect(viewport.size()));
-  }
-
-  client_->OnDraw();
-
-  // After software draws (which might move the viewport arbitrarily), restore
-  // the previous hardware viewport to allow CC's tile manager to prioritize
-  // properly.
-  if (hardware_draw) {
-    cached_hw_transform_ = adjusted_transform;
-    cached_hw_viewport_ = viewport;
-    cached_hw_clip_ = clip;
-    cached_hw_viewport_rect_for_tile_priority_ =
-        viewport_rect_for_tile_priority;
-    cached_hw_transform_for_tile_priority_ = transform_for_tile_priority;
-  } else {
-    bool resourceless_software_draw = false;
-    SetExternalDrawConstraints(cached_hw_transform_,
-                               cached_hw_viewport_,
-                               cached_hw_clip_,
-                               cached_hw_viewport_rect_for_tile_priority_,
-                               cached_hw_transform_for_tile_priority_,
-                               resourceless_software_draw);
-    // This draw may have reset all damage, which would lead to subsequent
-    // incorrect hardware draw, so explicitly set damage for next hardware
-    // draw as well.
-    next_hardware_draw_needs_damage_ = true;
-  }
+  client_->OnDraw(adjusted_transform, viewport, clip, software_draw);
 
   if (frame_holder_.get())
     client_->DidSwapBuffersComplete();
 }
 
 void SynchronousCompositorOutputSurface::ReturnResources(
     const cc::CompositorFrameAck& frame_ack) {
   ReclaimResources(&frame_ack);
 }
 
@@ skipping 31 matching lines @@
   scoped_ptr<FrameSwapMessageQueue::SendMessageScope> send_message_scope =
       frame_swap_message_queue_->AcquireSendMessageScope();
   frame_swap_message_queue_->DrainMessages(messages);
 }
 
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace content