Move compositor thread input handling logic into content

content/renderer/gpu/render_widget_compositor.h

 // 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.
 
 #ifndef CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
 #define CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_
 
+#include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "cc/debug/rendering_stats.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "skia/ext/refptr.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebLayerTreeView.h"
 #include "ui/gfx/rect.h"
 
 class SkPicture;
 
 namespace cc {
+class InputHandler;
 class LayerTreeHost;
 struct LatencyInfo;
 }
 
 namespace content {
 class RenderWidget;
 
 class RenderWidgetCompositor : public WebKit::WebLayerTreeView,
                                public cc::LayerTreeHostClient {
  public:
   // Attempt to construct and initialize a compositor instance for the widget
   // with the given settings. Returns NULL if initialization fails.
   static scoped_ptr<RenderWidgetCompositor> Create(RenderWidget* widget);
 
   virtual ~RenderWidgetCompositor();
 
+  const base::WeakPtr<cc::InputHandler>& GetInputHandler();

[piman, 2013/05/15 21:51:03]

nit: worth mentioning that the weakptr is bound to the impl thread (since this
is called from the main thread).

Do we need this WeakPtr though? It seems redundant with the
InputHandlerClient::WillShutdown.

For startup, assuming we don't call InputHandlerManager::AddInputHandler before
the compositor has been destroyed (from the main thread pov, which has to be the
case given the RenderViewImpl::didActivateCompositor code), then
InputHandlerManager::AddInputHandlerOnCompositorThread will necessarily execute
before ThreadProxy::LayerTreeHostClosedOnImplThread which destroys the
LTHI==InputHandler.

AddInputHandlerOnCompositorThread causes the BindToClient to happen, so you're
guaranteed that by the time LayerTreeHostClosedOnImplThread it will be able to
call WillShutdown (unless, I suppose, the InputHandlerProxy is gone before that,
in which case it doesn't matter any more). At that point you can reset
InputHandlerProxy::input_handler_.

   void SetSuppressScheduleComposite(bool suppress);
   void Animate(base::TimeTicks time);
   void Composite(base::TimeTicks frame_begin_time);
   void SetNeedsDisplayOnAllLayers();
   void GetRenderingStats(cc::RenderingStats* stats);
   skia::RefPtr<SkPicture> CapturePicture();
   void UpdateTopControlsState(bool enable_hiding,
                               bool enable_showing,
                               bool animate);
   void SetOverdrawBottomHeight(float overdraw_bottom_height);
@@ skipping 39 matching lines @@
 
   // cc::LayerTreeHostClient implementation.
   virtual void WillBeginFrame() OVERRIDE;
   virtual void DidBeginFrame() OVERRIDE;
   virtual void Animate(double frame_begin_time) OVERRIDE;
   virtual void Layout() OVERRIDE;
   virtual void ApplyScrollAndScale(gfx::Vector2d scroll_delta,
                                    float page_scale) OVERRIDE;
   virtual scoped_ptr<cc::OutputSurface> CreateOutputSurface() OVERRIDE;
   virtual void DidInitializeOutputSurface(bool success) OVERRIDE;
-  virtual scoped_ptr<cc::InputHandlerClient> CreateInputHandlerClient()
-      OVERRIDE;
   virtual void WillCommit() OVERRIDE;
   virtual void DidCommit() OVERRIDE;
   virtual void DidCommitAndDrawFrame() OVERRIDE;
   virtual void DidCompleteSwapBuffers() OVERRIDE;
   virtual void ScheduleComposite() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE;
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE;
 
-private:
+ private:
   explicit RenderWidgetCompositor(RenderWidget* widget);
 
   bool initialize(cc::LayerTreeSettings settings);
 
   bool threaded_;
   bool suppress_schedule_composite_;
   RenderWidget* widget_;
   scoped_ptr<cc::LayerTreeHost> layer_tree_host_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_RENDERER_GPU_RENDER_WIDGET_COMPOSITOR_H_