Test: deleting RTM before BVR does not leak resources.

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,
-                       RenderThreadManager* functor,
+                       const DrawGLCallback& draw_gl,
                        WindowHooks* hooks,
                        gfx::Rect location)
     : view_(view),
       hooks_(hooks),
       surface_size_(100, 100),
       location_(location),
       on_draw_hardware_pending_(false),
-      functor_(functor),
+      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();
-}
-
-void FakeWindow::Detach() {
-  CheckCurrentlyOnUIThread();
-  functor_->DeleteHardwareRendererOnUI();
-  view_->OnDetachedFromWindow();
-
   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) {
   CheckCurrentlyOnUIThread();
   base::WaitableEvent completion(true, false);
   render_thread_loop_->PostTask(
       FROM_HERE,
       base::Bind(&FakeWindow::ProcessFunctorOnRT, base::Unretained(this),
                  wait_for_completion ? &completion : nullptr));
   if (wait_for_completion)
     completion.Wait();
 }
 
 void FakeWindow::ProcessFunctorOnRT(base::WaitableEvent* sync) {
   CheckCurrentlyOnRT();
   AwDrawGLInfo process_info;
   process_info.version = kAwDrawGLInfoVersion;
   process_info.mode = AwDrawGLInfo::kModeProcess;
 
-  hooks_->WillProcessOnRT(functor_);
+  hooks_->WillProcessOnRT();
   {
     ScopedMakeCurrent make_current(this);
-    functor_->DrawGL(&process_info);
+    draw_gl_.Run(&process_info);
   }
-  hooks_->DidProcessOnRT(functor_);
+  hooks_->DidProcessOnRT();
 
   if (sync)
     sync->Signal();
 }
 
 void FakeWindow::PostInvalidate() {
   CheckCurrentlyOnUIThread();
   if (on_draw_hardware_pending_)
     return;
   on_draw_hardware_pending_ = true;
@@ skipping 24 matching lines @@
 
 void FakeWindow::DrawFunctorOnRT(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;
 
-    hooks_->WillSyncOnRT(functor_);
-    functor_->DrawGL(&process_info);
-    hooks_->DidSyncOnRT(functor_);
+    hooks_->WillSyncOnRT();
+    draw_gl_.Run(&process_info);
+    hooks_->DidSyncOnRT();
   }
   sync->Signal();
 
   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(functor_, &draw_info))
+  if (!hooks_->WillDrawOnRT(&draw_info))
     return;
 
   {
     ScopedMakeCurrent make_current(this);
-    functor_->DrawGL(&draw_info);
+    draw_gl_.Run(&draw_info);
   }
-  hooks_->DidDrawOnRT(functor_);
+  hooks_->DidDrawOnRT();
 }
 
 void FakeWindow::CheckCurrentlyOnUIThread() {
   DCHECK(ui_checker_.CalledOnValidSequencedThread());
 }
 
 void FakeWindow::CreateRenderThreadIfNeeded() {
   CheckCurrentlyOnUIThread();
   if (render_thread_) {
     DCHECK(render_thread_loop_);
@@ skipping 30 matching lines @@
     surface_ = nullptr;
   }
   sync->Signal();
 }
 
 void FakeWindow::CheckCurrentlyOnRT() {
   DCHECK(rt_checker_.CalledOnValidSequencedThread());
 }
 
 }  // namespace android_webview