WIP Handle AwContents needing multiple live functors.

android_webview/browser/test/fake_window.cc

 // 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.
 
 #include "android_webview/browser/test/fake_window.h"
 
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/render_thread_manager.h"
 #include "base/location.h"
@@ skipping 23 matching lines @@
     eglMakeCurrent(view_root_->surface_->GetDisplay(), EGL_NO_SURFACE,
                    EGL_NO_SURFACE, EGL_NO_CONTEXT);
     view_root_->context_->ReleaseCurrent(view_root_->surface_.get());
   }
 
  private:
   FakeWindow* view_root_;
 };
 
 FakeWindow::FakeWindow(BrowserViewRenderer* view,
-                       const DrawGLCallback& draw_gl,
                        WindowHooks* hooks,
                        gfx::Rect location)
     : view_(view),
       hooks_(hooks),
       surface_size_(100, 100),
       location_(location),
       on_draw_hardware_pending_(false),
-      draw_gl_(draw_gl),
       context_current_(false),
       weak_ptr_factory_(this) {
   CheckCurrentlyOnUIThread();
   DCHECK(view_);
   view_->OnAttachedToWindow(location_.width(), location_.height());
   view_->SetWindowVisibility(true);
   view_->SetViewVisibility(true);
 }
 
 FakeWindow::~FakeWindow() {
   CheckCurrentlyOnUIThread();
   if (render_thread_loop_) {
     base::WaitableEvent completion(true, false);
     render_thread_loop_->PostTask(
         FROM_HERE, base::Bind(&FakeWindow::DestroyOnRT, base::Unretained(this),
                               &completion));
     completion.Wait();
   }
 
   render_thread_.reset();
 }
 
 void FakeWindow::Detach() {
   CheckCurrentlyOnUIThread();
   view_->OnDetachedFromWindow();
 }
 
-void FakeWindow::RequestInvokeGL(bool wait_for_completion) {
+void FakeWindow::RequestInvokeGL(FakeFunctor* functor,
+                                 bool wait_for_completion) {
   CheckCurrentlyOnUIThread();
   base::WaitableEvent completion(true, false);
   render_thread_loop_->PostTask(
       FROM_HERE,
-      base::Bind(&FakeWindow::ProcessFunctorOnRT, base::Unretained(this),
-                 wait_for_completion ? &completion : nullptr));
+      base::Bind(&FakeWindow::InvokeFunctorOnRT, base::Unretained(this),
+                 functor, wait_for_completion ? &completion : nullptr));
   if (wait_for_completion)
     completion.Wait();
 }
 
-void FakeWindow::ProcessFunctorOnRT(base::WaitableEvent* sync) {
+void FakeWindow::InvokeFunctorOnRT(FakeFunctor* functor,
+                                   base::WaitableEvent* sync) {
   CheckCurrentlyOnRT();
-  AwDrawGLInfo process_info;
-  process_info.version = kAwDrawGLInfoVersion;
-  process_info.mode = AwDrawGLInfo::kModeProcess;
+  ScopedMakeCurrent make_current(this);
+  functor->Invoke(sync, hooks_);
+}
 
-  hooks_->WillProcessOnRT();
-  {
-    ScopedMakeCurrent make_current(this);
-    draw_gl_.Run(&process_info);
-  }
-  hooks_->DidProcessOnRT();
+void FakeWindow::SetDrawFunctor(FakeFunctor* functor) {
+  functor_ = functor;
+}
 
-  if (sync)
-    sync->Signal();
+void FakeWindow::RequestDrawGL(FakeFunctor* functor) {
+  CheckCurrentlyOnUIThread();
+  render_thread_loop_->PostTask(FROM_HERE,
+                                base::Bind(&FakeWindow::ProcessDrawOnRT,
+                                           base::Unretained(this), functor));
 }
 
 void FakeWindow::PostInvalidate() {
   CheckCurrentlyOnUIThread();
   if (on_draw_hardware_pending_)
     return;
   on_draw_hardware_pending_ = true;
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&FakeWindow::OnDrawHardware, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void FakeWindow::OnDrawHardware() {
   CheckCurrentlyOnUIThread();
   DCHECK(on_draw_hardware_pending_);
   on_draw_hardware_pending_ = false;
 
   view_->PrepareToDraw(gfx::Vector2d(), location_);
   hooks_->WillOnDraw();
   bool success = view_->OnDrawHardware();
   hooks_->DidOnDraw(success);
+  FakeFunctor* functor = hooks_->GetFunctorForView(view_);
+  DCHECK(functor);

[boliu, 2016/05/13 16:09:02]

fwiw, production code should handle the case where no functor is called after
OnDraw. doesn't need to change this now, but we could unit test that as well

[Tobias Sargeant, 2016/05/13 17:02:37]

Seems like we could simulate this by returning nullptr from GetFunctorForView.
Modified to allow this.

   if (success) {
     CreateRenderThreadIfNeeded();
 
     base::WaitableEvent completion(true, false);
     render_thread_loop_->PostTask(
         FROM_HERE, base::Bind(&FakeWindow::DrawFunctorOnRT,
-                              base::Unretained(this), &completion));
+                              base::Unretained(this), functor, &completion));
     completion.Wait();
   }
 }
 
-void FakeWindow::DrawFunctorOnRT(base::WaitableEvent* sync) {
+void FakeWindow::ProcessSyncOnRT(FakeFunctor* functor,
+                                 base::WaitableEvent* sync) {
   CheckCurrentlyOnRT();
-  // Ok to access UI functions until sync is signalled.
-  gfx::Rect location = location_;
-  {
-    AwDrawGLInfo process_info;
-    process_info.version = kAwDrawGLInfoVersion;
-    process_info.mode = AwDrawGLInfo::kModeSync;
+  functor->Sync(location_, sync, hooks_);
+}
 
-    hooks_->WillSyncOnRT();
-    draw_gl_.Run(&process_info);
-    hooks_->DidSyncOnRT();
-  }
-  sync->Signal();
+void FakeWindow::ProcessDrawOnRT(FakeFunctor* functor) {
+  CheckCurrentlyOnRT();
+  ScopedMakeCurrent make_current(this);
+  functor->Draw(hooks_);
+}
 
-  AwDrawGLInfo draw_info;
-  draw_info.version = kAwDrawGLInfoVersion;
-  draw_info.mode = AwDrawGLInfo::kModeDraw;
-  draw_info.clip_left = location.x();
-  draw_info.clip_top = location.y();
-  draw_info.clip_right = location.x() + location.width();
-  draw_info.clip_bottom = location.y() + location.height();
-
-  if (!hooks_->WillDrawOnRT(&draw_info))
-    return;
-
-  {
-    ScopedMakeCurrent make_current(this);
-    draw_gl_.Run(&draw_info);
-  }
-  hooks_->DidDrawOnRT();
+void FakeWindow::DrawFunctorOnRT(FakeFunctor* functor,
+                                 base::WaitableEvent* sync) {
+  ProcessSyncOnRT(functor, sync);
+  ProcessDrawOnRT(functor);
 }
 
 void FakeWindow::CheckCurrentlyOnUIThread() {
   DCHECK(ui_checker_.CalledOnValidSequencedThread());
 }
 
 void FakeWindow::CreateRenderThreadIfNeeded() {
   CheckCurrentlyOnUIThread();
   if (render_thread_) {
     DCHECK(render_thread_loop_);
@@ skipping 29 matching lines @@
     context_ = nullptr;
     surface_ = nullptr;
   }
   sync->Signal();
 }
 
 void FakeWindow::CheckCurrentlyOnRT() {
   DCHECK(rt_checker_.CalledOnValidSequencedThread());
 }
 
+FakeFunctor::FakeFunctor() : window_(nullptr) {}
+
+FakeFunctor::~FakeFunctor() {
+  render_thread_manager_.reset();
+}
+
+CompositorFrameConsumer* FakeFunctor::GetCompositorFrameConsumer() {
+  return render_thread_manager_.get();
+}
+
+void FakeFunctor::Init(
+    FakeWindow* window,
+    std::unique_ptr<RenderThreadManager> render_thread_manager) {
+  window_ = window;
+  render_thread_manager_ = std::move(render_thread_manager);
+  callback_ = base::Bind(&RenderThreadManager::DrawGL,
+                         base::Unretained(render_thread_manager_.get()));
+}
+
+void FakeFunctor::Sync(const gfx::Rect& location,
+                       base::WaitableEvent* sync,
+                       WindowHooks* hooks) {
+  DCHECK(!callback_.is_null());
+  committed_location_ = location;
+  AwDrawGLInfo sync_info;
+  sync_info.version = kAwDrawGLInfoVersion;
+  sync_info.mode = AwDrawGLInfo::kModeSync;
+  hooks->WillSyncOnRT();
+  callback_.Run(&sync_info);
+  hooks->DidSyncOnRT();
+  sync->Signal();

[boliu, 2016/05/13 16:09:01]

My earlier comment about not having sync objects in FakeFunctor is still not
addressed.

Conceptually, functor only cares about functor being called, and it's some
external thing that's guaranteeing any synchronization behavior.

both sync->Signal call is the last thing in the method, so why not just hoist
that up to the caller from FakeWindow?

[Tobias Sargeant, 2016/05/13 16:23:17]

Ahh, OK, I misunderstood what you meant the first time around. I thought you
meant Sync as in kModeSync, not the WaitableEvent objects. Makes much  more
sense now.

[Tobias Sargeant, 2016/05/13 17:02:36]

Done.

+}
+
+void FakeFunctor::Draw(WindowHooks* hooks) {
+  DCHECK(!callback_.is_null());
+  AwDrawGLInfo draw_info;
+  draw_info.version = kAwDrawGLInfoVersion;
+  draw_info.mode = AwDrawGLInfo::kModeDraw;
+  draw_info.clip_left = committed_location_.x();
+  draw_info.clip_top = committed_location_.y();
+  draw_info.clip_right = committed_location_.x() + committed_location_.width();
+  draw_info.clip_bottom =
+      committed_location_.y() + committed_location_.height();
+  if (!hooks->WillDrawOnRT(&draw_info))
+    return;
+  callback_.Run(&draw_info);
+  hooks->DidDrawOnRT();
+}
+
+void FakeFunctor::Invoke(base::WaitableEvent* sync, WindowHooks* hooks) {
+  DCHECK(!callback_.is_null());
+  AwDrawGLInfo invoke_info;
+  invoke_info.version = kAwDrawGLInfoVersion;
+  invoke_info.mode = AwDrawGLInfo::kModeProcess;
+  hooks->WillProcessOnRT();
+  callback_.Run(&invoke_info);
+  hooks->DidProcessOnRT();
+  if (sync)
+    sync->Signal();
+}
+
+bool FakeFunctor::RequestInvokeGL(bool wait_for_completion) {
+  DCHECK(window_);
+  window_->RequestInvokeGL(this, wait_for_completion);
+  return true;
+}
+
+void FakeFunctor::DetachFunctorFromView() {}
+
 }  // namespace android_webview