WIP Handle AwContents needing multiple live functors.

android_webview/browser/test/fake_window.h

 // Copyright 2014 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 ANDROID_WEBVIEW_BROWSER_TEST_FAKE_WINDOW_H_
 #define ANDROID_WEBVIEW_BROWSER_TEST_FAKE_WINDOW_H_
 
 #include <map>
 
+#include "android_webview/browser/render_thread_manager.h"

[boliu, 2016/05/10 15:18:19]

forward declare?

[Tobias Sargeant, 2016/05/13 13:23:57]

Done.

+#include "android_webview/browser/render_thread_manager_client.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 
 namespace base {
 class Thread;
 class WaitableEvent;
 }
 
 namespace android_webview {
 
 class BrowserViewRenderer;
+class Functor;
 
 class WindowHooks {
  public:
   virtual ~WindowHooks() {}
 
   virtual void WillOnDraw() = 0;
   virtual void DidOnDraw(bool success) = 0;
 
   virtual void WillSyncOnRT() = 0;
   virtual void DidSyncOnRT() = 0;
   virtual void WillProcessOnRT() = 0;
   virtual void DidProcessOnRT() = 0;
   virtual bool WillDrawOnRT(AwDrawGLInfo* draw_info) = 0;
   virtual void DidDrawOnRT() = 0;
 };
 
 class FakeWindow {
  public:
-  using DrawGLCallback = base::Callback<void(AwDrawGLInfo*)>;
-
-  FakeWindow(BrowserViewRenderer* view,
-             const DrawGLCallback& draw_gl,
-             WindowHooks* hooks,
-             gfx::Rect location);
+  FakeWindow(BrowserViewRenderer* view, WindowHooks* hooks, gfx::Rect location);
   ~FakeWindow();
 
   void Detach();
 
-  // BrowserViewRendererClient methods.
-  void RequestInvokeGL(bool wait_for_completion);
+  void RequestInvokeGL(Functor* functor, bool wait_for_completion);
   void PostInvalidate();
   const gfx::Size& surface_size() { return surface_size_; }
 
+  void SetDrawFunctor(Functor* functor);
+  void RequestDrawGL(Functor* functor);
+
  private:
   class ScopedMakeCurrent;
 
   void OnDrawHardware();
   void CheckCurrentlyOnUIThread();
   void CreateRenderThreadIfNeeded();
 
   void InitializeOnRT(base::WaitableEvent* sync);
   void DestroyOnRT(base::WaitableEvent* sync);
-  void ProcessFunctorOnRT(base::WaitableEvent* sync);
-  void DrawFunctorOnRT(base::WaitableEvent* sync);
+  void InvokeFunctorOnRT(Functor* functor, base::WaitableEvent* sync);
+  void ProcessSyncOnRT(Functor* functor, base::WaitableEvent* sync);
+  void ProcessDrawOnRT(Functor* functor);
+  void DrawFunctorOnRT(Functor* functor, base::WaitableEvent* sync);
   void CheckCurrentlyOnRT();

[boliu, 2016/05/10 15:18:19]

style: keep blank line below

[Tobias Sargeant, 2016/05/13 13:23:56]

Done.

-
   // const so can be used on both threads.
   BrowserViewRenderer* const view_;
   WindowHooks* const hooks_;
   const gfx::Size surface_size_;
 
   // UI thread members.
   gfx::Rect location_;
   bool on_draw_hardware_pending_;
   base::SequenceChecker ui_checker_;
 
   // Render thread members.
   std::unique_ptr<base::Thread> render_thread_;
   base::SequenceChecker rt_checker_;
-  DrawGLCallback draw_gl_;
   scoped_refptr<base::SingleThreadTaskRunner> render_thread_loop_;
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
   bool context_current_;
+  Functor* functor_;

[boliu, 2016/05/10 15:18:19]

there is nothing really guaranteeing lifetime between functor and fakewindow, is
it safe to use the other from their destructor for example?

[Tobias Sargeant, 2016/05/13 13:23:57]

True. It's slightly better now that FakeWindow doesn't have a Functor pointer,
but there's still the reverse direction. RenderingTest manages both, and
enforces (at least for the default single functor) that it is destroyed before
the FakwWindow instance. Maybe this can be cleaned up some more?

 
   base::WeakPtrFactory<FakeWindow> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeWindow);
 };
 
+class Functor : public RenderThreadManagerClient {

[boliu, 2016/05/10 15:18:19]

TestFunctor or something that implies it's not a production object

[Tobias Sargeant, 2016/05/13 13:23:57]

Done.

+ public:
+  using DrawGLCallback = base::Callback<void(AwDrawGLInfo*)>;
+  using RenderThreadManagerFactory =
+      base::Callback<RenderThreadManager*(RenderThreadManagerClient*)>;
+
+  Functor(RenderThreadManagerFactory render_thread_manager_factory);

[boliu, 2016/05/10 15:18:19]

explicit, const&

[Tobias Sargeant, 2016/05/13 13:23:57]

Took your Init suggestion, no need for this constructor now.

+  ~Functor() override;
+
+  CompositorFrameConsumer* GetCompositorFrameConsumer();
+  void Attach(FakeWindow* window);
+  void Sync(const gfx::Rect& location,
+            base::WaitableEvent* sync,
+            WindowHooks* hooks);
+  void Draw(WindowHooks* hooks);
+  void Invoke(base::WaitableEvent* sync, WindowHooks* hooks);
+
+  // RenderThreadManagerClient overrides
+  bool RequestInvokeGL(bool wait_for_completion) override;
+  void DetachFunctorFromView() override;
+
+ private:
+  FakeWindow* window_;
+  DrawGLCallback callback_;
+  std::unique_ptr<RenderThreadManager> render_thread_manager_;
+  gfx::Rect committed_location_;
+};
+
 }  // namespace android_webview
 
 #endif  // ANDROID_WEBVIEW_BROWSER_TEST_FAKE_WINDOW_H_