TrimMemory strategy while offscreenPreRaster is on.

android_webview/browser/shared_renderer_state.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/shared_renderer_state.h"
 
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
 #include "android_webview/browser/hardware_renderer.h"
@@ skipping 267 matching lines @@
     hardware_renderer_->CommitFrame();
   }
 
   hardware_renderer_->DrawGL(state_restore.stencil_enabled(),
                              state_restore.framebuffer_binding_ext(),
                              draw_info);
   DeferredGpuCommandService::GetInstance()->PerformIdleWork(false);
 }
 
 void SharedRendererState::ReleaseHardwareDrawIfNeededOnUI() {
+  ReleaseCompositorResourcesIfNeededOnUI(false);
+}
+
+void SharedRendererState::DeleteHardwareRendererOnUI() {
+  ReleaseCompositorResourcesIfNeededOnUI(true);
+}
+
+void SharedRendererState::ReleaseCompositorResourcesIfNeededOnUI(
+    bool keep_child_compositor_tiles) {

[boliu, 2015/04/16 01:58:40]

release_hardware_draw?

This class doesn't know anything about tiles

[hush (inactive), 2015/04/16 04:06:25]

Done.

   DCHECK(ui_loop_->BelongsToCurrentThread());
   InsideHardwareReleaseReset auto_inside_hardware_release_reset(this);
 
   browser_view_renderer_->DetachFunctorFromView();
   bool hardware_initialized = browser_view_renderer_->hardware_enabled();
   if (hardware_initialized) {

[boliu, 2015/04/16 01:58:40]

This check doesn't catch all cases anymore, since it's possible to have
hardware_enabled() and yet not have a hardware renderer (ie get trimmed twice)

But can't think of anything better either, so maybe just add a comment about
that

[hush (inactive), 2015/04/16 04:06:25]

Are you only worried about the 2nd onTrimMemory being wasteful?
If WebView gets trimmed twice, we just call hardware_renderer_->reset() twice in
a row. It is wasteful, but still not a bug. Or we can introduce another boolean
state for cases where the hardware renderer is gone but the UI compositor is
still valid. But this would make the code more complicated.

[boliu, 2015/04/16 04:14:06]

The wasteful part is 2 state restores, and blocking the UI thread.
Yeah not worth the complexity. That's why I said just add a comment.

     bool draw_functor_succeeded = browser_view_renderer_->RequestDrawGL(true);
     if (!draw_functor_succeeded) {
       LOG(ERROR) << "Unable to free GL resources. Has the Window leaked?";
       // Calling release on wrong thread intentionally.
       AwDrawGLInfo info;
       info.mode = AwDrawGLInfo::kModeProcess;
       DrawGL(&info);
     }
 
-    browser_view_renderer_->ReleaseHardware();
+    if (!keep_child_compositor_tiles)
+      browser_view_renderer_->ReleaseHardware();
   }
 
   GLViewRendererManager* manager = GLViewRendererManager::GetInstance();
 
   {
     base::AutoLock lock(lock_);
     if (renderer_manager_key_ != manager->NullKey()) {
       manager->Remove(renderer_manager_key_);
       renderer_manager_key_ = manager->NullKey();
     }
   }
 
-  if (hardware_initialized) {
+  if (hardware_initialized && !keep_child_compositor_tiles) {

[boliu, 2015/04/16 01:58:40]

Can't skip this (in theory), some other thread can still get hold of the key
from RendererManager, and schedule something synchronous, which needs to be
cleared, ie don't change this line.

[hush (inactive), 2015/04/16 04:06:25]

Removed the additional condition.
What's the situation for this to happen?
You mean something in GPU thread could get hold of the key during
"PerformIdleWork" after hardware renderer destruction and schedule something
synchronous?

     // Flush any invoke functors that's caused by ReleaseHardware.
     browser_view_renderer_->RequestDrawGL(true);
   }
 }
 
 void SharedRendererState::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);
     DeferredGpuCommandService::SetInstance();
   }
 }
 
 SharedRendererState::InsideHardwareReleaseReset::InsideHardwareReleaseReset(
     SharedRendererState* shared_renderer_state)
     : shared_renderer_state_(shared_renderer_state) {
   DCHECK(!shared_renderer_state_->IsInsideHardwareRelease());
   shared_renderer_state_->SetInsideHardwareRelease(true);
 }
 
 SharedRendererState::InsideHardwareReleaseReset::~InsideHardwareReleaseReset() {
   shared_renderer_state_->SetInsideHardwareRelease(false);
 }
 
 }  // namespace android_webview