aw: Quick workaround for functor detach crash/hang

android_webview/browser/render_thread_manager.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/render_thread_manager.h"
 
 #include <utility>
 
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
@@ skipping 262 matching lines @@
     }
   }
 
   ScopedAppGLStateRestore state_restore(
       draw_info->mode == AwDrawGLInfo::kModeDraw
           ? ScopedAppGLStateRestore::MODE_DRAW
           : ScopedAppGLStateRestore::MODE_RESOURCE_MANAGEMENT);
   // Set the correct FBO before kModeDraw. The GL commands run in kModeDraw
   // require a correctly bound FBO. The FBO remains until the next kModeDraw.
   // So kModeProcess between kModeDraws has correctly bound FBO, too.
-  if (draw_info->mode == AwDrawGLInfo::kModeDraw) {
-    if (!hardware_renderer_) {
-      hardware_renderer_.reset(new HardwareRenderer(this));
-      hardware_renderer_->CommitFrame();
-    }
+  if (draw_info->mode == AwDrawGLInfo::kModeDraw && !hardware_renderer_ &&
+      HasFrameForHardwareRendererOnRT()) {
+    hardware_renderer_.reset(new HardwareRenderer(this));
+    hardware_renderer_->CommitFrame();
+  }
+  if (hardware_renderer_) {
     hardware_renderer_->SetBackingFrameBufferObject(
         state_restore.framebuffer_binding_ext());
   }
 
   ScopedAllowGL allow_gl;
 
   if (draw_info->mode == AwDrawGLInfo::kModeProcessNoContext) {
     LOG(ERROR) << "Received unexpected kModeProcessNoContext";
   }
 
   if (IsInsideHardwareRelease()) {
     hardware_renderer_has_frame_ = false;
     hardware_renderer_.reset();
     // Flush the idle queue in tear down.
     DeferredGpuCommandService::GetInstance()->PerformAllIdleWork();
     return;
   }
 
   if (draw_info->mode != AwDrawGLInfo::kModeDraw) {
     if (draw_info->mode == AwDrawGLInfo::kModeProcess) {
       DeferredGpuCommandService::GetInstance()->PerformIdleWork(true);
     }
     return;
   }
 
-  hardware_renderer_->DrawGL(draw_info, state_restore);
+  if (hardware_renderer_)
+    hardware_renderer_->DrawGL(draw_info, state_restore);
   DeferredGpuCommandService::GetInstance()->PerformIdleWork(false);
 }
 
 void RenderThreadManager::DeleteHardwareRendererOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
 
   InsideHardwareReleaseReset auto_inside_hardware_release_reset(this);
 
   client_->DetachFunctorFromView();
 
@@ skipping 25 matching lines @@
     // Flush any invoke functors that's caused by ReleaseHardware.
     client_->RequestDrawGL(true);
   }
 }
 
 bool RenderThreadManager::HasFrameOnUI() const {
   base::AutoLock lock(lock_);
   return hardware_renderer_has_frame_ || child_frame_.get();
 }
 
+bool RenderThreadManager::HasFrameForHardwareRendererOnRT() const {
+  base::AutoLock lock(lock_);
+  return !!child_frame_;
+}
+
 void RenderThreadManager::InitializeHardwareDrawIfNeededOnUI() {
   DCHECK(ui_loop_->BelongsToCurrentThread());
   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
 
   base::AutoLock lock(lock_);
   if (renderer_manager_key_ == manager->NullKey()) {
     renderer_manager_key_ = manager->PushBack(this);
   }
 }
 
 RenderThreadManager::InsideHardwareReleaseReset::InsideHardwareReleaseReset(
     RenderThreadManager* render_thread_manager)
     : render_thread_manager_(render_thread_manager) {
   DCHECK(!render_thread_manager_->IsInsideHardwareRelease());
   render_thread_manager_->SetInsideHardwareRelease(true);
 }
 
 RenderThreadManager::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
   render_thread_manager_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview