Force spontaneous draws into the SW path

content/browser/android/in_process/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/browser/android/in_process/synchronous_compositor_output_surface.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "cc/output/begin_frame_args.h"
@@ skipping 70 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
     int routing_id)
     : cc::OutputSurface(
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
       routing_id_(routing_id),
       needs_begin_frame_(false),
+      invoking_composite_(false),
       did_swap_buffer_(false),
       current_sw_canvas_(NULL) {
   capabilities_.deferred_gl_initialization = true;
   capabilities_.adjust_deadline_for_parent = false;
   // Cannot call out to GetDelegate() here as the output surface is not
   // constructed on the correct thread.
 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->DidDestroySynchronousOutputSurface(this);
 }
 
 bool SynchronousCompositorOutputSurface::ForcedDrawToSoftwareDevice() const {
-  return current_sw_canvas_ != NULL;
+  // |current_sw_canvas_| indicates we're in a DemandDrawSw call. In addition
+  // |invoking_composite_| == false indicates an attempt to draw outside of
+  // the synchronous compositor's control: force it into SW path and hence to
+  // the null canvas (and will log a warning there).
+  return current_sw_canvas_ != NULL || !invoking_composite_;
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->DidBindOutputSurface(this);
   return true;
 }
 
 void SynchronousCompositorOutputSurface::Reshape(
     gfx::Size size, float scale_factor) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SetNeedsBeginFrame(
     bool enable) {
   DCHECK(CalledOnValidThread());
   cc::OutputSurface::SetNeedsBeginFrame(enable);
   needs_begin_frame_ = enable;
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->SetContinuousInvalidate(needs_begin_frame_);
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(

[boliu, 2013/06/21 22:44:23]

Hmm...slightly tangent, but we could invalidate the view from here if
(!invoking_compositing), so a forced draw is always followed by a real draw...oh
the hacks

[joth, 2013/06/21 23:02:14]

yeah...... I'd rather not make it any more complicated. The code as it stands is
mostly funnelling us to the NOTREACHED() on line 64 anyway, so no point having
even more workaround beyond it.

     cc::CompositorFrame* frame) {
   if (!ForcedDrawToSoftwareDevice()) {
     DCHECK(context3d());
     context3d()->shallowFlushCHROMIUM();
   }
   SynchronousCompositorOutputSurfaceDelegate* delegate = GetDelegate();
   if (delegate)
     delegate->UpdateFrameMetaData(frame->metadata);
 
   did_swap_buffer_ = true;
@@ skipping 64 matching lines @@
   SetExternalDrawConstraints(transform, clip);
 
   InvokeComposite(clip.size());
 
   current_sw_canvas_ = NULL;
   return did_swap_buffer_;
 }
 
 void SynchronousCompositorOutputSurface::InvokeComposite(
     gfx::Size damage_size) {
+  invoking_composite_ = true;

[boliu, 2013/06/21 22:40:14]

Use base::AutoReset?

[joth, 2013/06/21 23:02:14]

Done.

Nice! Thought that existed, but I was searching the code for a ScopedFlibble
class...

   did_swap_buffer_ = false;
   SetNeedsRedrawRect(gfx::Rect(damage_size));
   if (needs_begin_frame_)
     BeginFrame(cc::BeginFrameArgs::CreateForSynchronousCompositor());
 
   if (did_swap_buffer_)
     OnSwapBuffersComplete(NULL);
+  invoking_composite_ = false;
 }
 
 void SynchronousCompositorOutputSurface::PostCheckForRetroactiveBeginFrame() {
   // Synchronous compositor cannot perform retroactive begin frames, so
   // intentionally no-op here.
 }
 
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
 // requirement: SynchronousCompositorOutputSurface() must only be used on the UI
 // thread.
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
   return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 SynchronousCompositorOutputSurfaceDelegate*
 SynchronousCompositorOutputSurface::GetDelegate() {
   return SynchronousCompositorImpl::FromRoutingID(routing_id_);
 }
 
 }  // namespace content