Move SynchronousCompositor into content/browser

content/browser/android/in_process/synchronous_compositor_output_surface.cc

 // Copyright (c) 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 "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/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/software_output_device.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/renderer/android/synchronous_compositor_client.h"
-#include "content/public/renderer/content_renderer_client.h"
 #include "skia/ext/refptr.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 #include "webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 using webkit::gpu::WebGraphicsContext3DInProcessCommandBufferImpl;
@@ skipping 52 matching lines @@
 
  private:
   SynchronousCompositorOutputSurface* surface_;
   SkDevice null_device_;
   SkCanvas null_canvas_;
 
   DISALLOW_COPY_AND_ASSIGN(SoftwareDevice);
 };
 
 SynchronousCompositorOutputSurface::SynchronousCompositorOutputSurface(
-    SynchronousCompositorOutputSurfaceDelegate* delegate)
+    int routing_id)
     : cc::OutputSurface(
           CreateWebGraphicsContext3D(),
           scoped_ptr<cc::SoftwareOutputDevice>(new SoftwareDevice(this))),
-      delegate_(delegate),
+      routing_id_(routing_id),
+      delegate_(NULL),
       needs_begin_frame_(false),
       did_swap_buffer_(false),
       current_sw_canvas_(NULL) {
   capabilities_.deferred_gl_initialization = true;

[joth, 2013/05/29 06:05:10]

// Do not call out to SynchronousCompositorImpl here as we're on the wrong
thread.

[joth, 2013/05/29 20:19:08]

Done.

 }
 
 SynchronousCompositorOutputSurface::~SynchronousCompositorOutputSurface() {
   DCHECK(CalledOnValidThread());
-  delegate_->DidDestroySynchronousOutputSurface();
+  if (delegate_)
+    delegate_->DidDestroySynchronousOutputSurface();

[joth, 2013/05/29 06:05:10]

pass |this| for consistency with the DidBindOutputSurface() call?

[mkosiba (inactive), 2013/05/29 15:31:58]

sounds like a good idea. we can add a DCHECK to check that the calls match up.

[joth, 2013/05/29 20:19:08]

Done.

 }
 
 bool SynchronousCompositorOutputSurface::ForcedDrawToSoftwareDevice() const {
   return current_sw_canvas_ != NULL;
 }
 
 bool SynchronousCompositorOutputSurface::BindToClient(
     cc::OutputSurfaceClient* surface_client) {
   DCHECK(CalledOnValidThread());
   if (!cc::OutputSurface::BindToClient(surface_client))
     return false;
-  delegate_->DidCreateSynchronousOutputSurface();
+  // TODO(joth): The SynchronousCompositorOutputSurfaceDelegate is fairly
+  // pointless if we're statically calling out to SynchronousCompositorImpl
+  // here.

[joth, 2013/05/29 06:05:10]

My current thinking is to delete the SynchronousCompositorOutputSurfaceDelegate
abstraction and have the sync compositor and its output surface be mutually
aware of each other.

[mkosiba (inactive), 2013/05/29 15:31:58]

Umm.. SynchronousCompositorImpl will end up containing quite a few methods, so
having separate intefaces to organize those seems like a nice idea to me. Does
removing the delegate buy us any flexibility or is it just a convenience thing?

IOW. The pattern for getting the SCImpl bellow is fine, it's just that I'd
perfer this class view SCImpl via the delegate interface, so maybe add a method
like this

SynchronousCompositorOutputSurfaceDeleagate* delegate() {
  return SynchronousCompositorImpl::FromRoutingId(routing_id);
}

and use it instead of delegate_ ?

[joth, 2013/05/29 20:19:08]

Done.

+  SynchronousCompositorImpl::DidBindOutputSurface(routing_id_, this);

[joth, 2013/05/29 06:05:10]

this could be 
SynchronousCompositorImpl::FromRoutingID(routing_id_)->DidBindOutputSurface(this);

or even
delegate = SynchronousCompositorImpl::FromRoutingID(routing_id_);
delegate->DidBindOutputSurface(this);

[joth, 2013/05/29 20:19:08]

(obsolete)

   return true;
 }
 
 void SynchronousCompositorOutputSurface::Reshape(
     gfx::Size size, float scale_factor) {
   // Intentional no-op: surface size is controlled by the embedder.
 }
 
 void SynchronousCompositorOutputSurface::SendFrameToParentCompositor(
     cc::CompositorFrame* frame) {
   NOTREACHED();
   // TODO(joth): Route page scale to the client, see http://crbug.com/237006
 }
 
 void SynchronousCompositorOutputSurface::SetNeedsBeginFrame(
     bool enable) {
   DCHECK(CalledOnValidThread());
   needs_begin_frame_ = enable;
-  delegate_->SetContinuousInvalidate(needs_begin_frame_);
+  if (delegate_)
+    delegate_->SetContinuousInvalidate(needs_begin_frame_);
 }
 
 void SynchronousCompositorOutputSurface::SwapBuffers(
     const cc::LatencyInfo& info) {
   context3d()->shallowFlushCHROMIUM();
   did_swap_buffer_ = true;
 }
 
 bool SynchronousCompositorOutputSurface::IsHwReady() {
   return context3d() != NULL;
@@ skipping 41 matching lines @@
     const gfx::Transform& transform,
     gfx::Rect damage_area) {
   // TODO(boliu): This assumes |transform| is identity and |damage_area| is the
   // whole view. Tracking bug to implement this: crbug.com/230463.
   client_->SetNeedsRedrawRect(damage_area);
   if (needs_begin_frame_)
     client_->BeginFrame(base::TimeTicks::Now());
 }
 
 // Not using base::NonThreadSafe as we want to enforce a more exacting threading
-// requirement: SynchronousCompositorOutputSurface() must only be used by
-// embedders that supply their own compositor loop via
-// OverrideCompositorMessageLoop().
+// requirement: SynchronousCompositorOutputSurface() must only be used on the UI
+// thread.
 bool SynchronousCompositorOutputSurface::CalledOnValidThread() const {
-  return base::MessageLoop::current() && (base::MessageLoop::current() ==
-      GetContentClient()->renderer()->OverrideCompositorMessageLoop());
+  return BrowserThread::CurrentlyOn(BrowserThread::UI);
 }
 
 }  // namespace content