Android: Don't destroy LayerTreeHost when Surface goes away

content/browser/renderer_host/compositor_impl_android.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/compositor_impl_android.h"
 
 #include <android/bitmap.h>
 #include <android/native_window_jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 201 matching lines @@
       new cc::SurfaceIdAllocator(++g_surface_id_namespace));
   cc::SurfaceManager* manager = GetSurfaceManager();
   DCHECK(manager);
   allocator->RegisterSurfaceIdNamespace(manager);
   return allocator.Pass();
 }
 
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create(Compositor::LayerSettings())),
-      resource_manager_(&ui_resource_provider_),
       surface_id_allocator_(GetSurfaceManager() ? CreateSurfaceIdAllocator()
                                                 : nullptr),
       has_transparent_background_(false),
       device_scale_factor_(1),
       window_(NULL),
       surface_id_(0),
       client_(client),
       root_window_(root_window),
       did_post_swapbuffers_(false),
       ignore_schedule_composite_(false),
       needs_composite_(false),
       needs_animate_(false),
       will_composite_immediately_(false),
       composite_on_vsync_trigger_(DO_NOT_COMPOSITE),
       pending_swapbuffers_(0U),
       num_successive_context_creation_failures_(0),
       output_surface_request_pending_(false),
       weak_factory_(this) {
   DCHECK(client);
   DCHECK(root_window);
   root_window->AttachCompositor(this);
+  CreateLayerTreeHost();
+  resource_manager_.Init(host_.get());
 }
 
 CompositorImpl::~CompositorImpl() {
   root_window_->DetachCompositor();
   // Clean-up any surface references.
   SetSurface(NULL);
 }
 
 void CompositorImpl::PostComposite(CompositingTrigger trigger) {
+  DCHECK(host_->visible());
   DCHECK(needs_composite_);
   DCHECK(trigger == COMPOSITE_IMMEDIATELY || trigger == COMPOSITE_EVENTUALLY);
 
   if (will_composite_immediately_ ||
       (trigger == COMPOSITE_EVENTUALLY && WillComposite())) {
     // We will already composite soon enough.
     DCHECK(WillComposite());
     return;
   }
 
@@ skipping 43 matching lines @@
   current_composite_task_.reset(new base::CancelableClosure(
       base::Bind(&CompositorImpl::Composite, base::Unretained(this), trigger)));
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, current_composite_task_->callback(), delay);
 }
 
 void CompositorImpl::Composite(CompositingTrigger trigger) {
   if (trigger == COMPOSITE_IMMEDIATELY)
     will_composite_immediately_ = false;
 
-  DCHECK(host_);
+  DCHECK(host_->visible());
   DCHECK(trigger == COMPOSITE_IMMEDIATELY || trigger == COMPOSITE_EVENTUALLY);
   DCHECK(needs_composite_);
   DCHECK(!DidCompositeThisFrame());
 
   DCHECK_LE(pending_swapbuffers_, kMaxSwapBuffers);
   // Swap Ack accounting is unreliable if the OutputSurface was lost.
   // In that case still attempt to composite, which will cause creation of a
   // new OutputSurface and reset pending_swapbuffers_.
   if (pending_swapbuffers_ == kMaxSwapBuffers &&
       !host_->output_surface_lost()) {
     TRACE_EVENT0("compositor", "CompositorImpl_SwapLimit");
     return;
   }
 
   // Reset state before Layout+Composite since that might create more
   // requests to Composite that we need to respect.
   needs_composite_ = false;
 
   // Only allow compositing once per vsync.
   current_composite_task_->Cancel();
   DCHECK(DidCompositeThisFrame() && !WillComposite());
 
-  // Ignore ScheduleComposite() from layer tree changes during layout and
-  // animation updates that will already be reflected in the current frame
-  // we are about to draw.
-  ignore_schedule_composite_ = true;
-
   const base::TimeTicks frame_time = base::TimeTicks::Now();
   if (needs_animate_) {
+    base::AutoReset<bool> auto_reset_ignore_schedule(
+        &ignore_schedule_composite_, true);
     needs_animate_ = false;
     root_window_->Animate(frame_time);
   }
-  ignore_schedule_composite_ = false;
 
   did_post_swapbuffers_ = false;
   host_->Composite(frame_time);
   if (did_post_swapbuffers_)
     pending_swapbuffers_++;
 
   // Need to track vsync to avoid compositing more than once per frame.
   root_window_->RequestVSyncUpdate();
 }
 
 ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
-  return ui_resource_provider_;
+  return *this;
 }
 
 ui::ResourceManager& CompositorImpl::GetResourceManager() {
   return resource_manager_;
 }
 
 void CompositorImpl::SetRootLayer(scoped_refptr<cc::Layer> root_layer) {
   if (subroot_layer_.get()) {
     subroot_layer_->RemoveFromParent();
     subroot_layer_ = NULL;
@@ skipping 50 matching lines @@
   if (window) {
     SetWindowSurface(window);
     ANativeWindow_release(window);
     RegisterViewSurface(surface_id_, j_surface.obj());
   }
 }
 
 void CompositorImpl::CreateLayerTreeHost() {
   DCHECK(!host_);
   DCHECK(!WillCompositeThisFrame());
-  needs_composite_ = false;
-  pending_swapbuffers_ = 0;
+
+  // Just in case, since we immediately hide the LTH in this function,
+  // and we do not want to end up with a pending Composite task when the
+  // host is hidden.
+  base::AutoReset<bool> auto_reset_ignore_schedule(&ignore_schedule_composite_,
+                                                   true);
+
   cc::LayerTreeSettings settings;
   settings.renderer_settings.refresh_rate = 60.0;
   settings.renderer_settings.allow_antialiasing = false;
   settings.renderer_settings.highp_threshold_min = 2048;
   settings.use_zero_copy = true;
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   settings.initial_debug_state.SetRecordRenderingStats(
       command_line->HasSwitch(cc::switches::kEnableGpuBenchmarking));
   settings.initial_debug_state.show_fps_counter =
       command_line->HasSwitch(cc::switches::kUIShowFPSCounter);
   // TODO(enne): Update this this compositor to use the scheduler.
   settings.single_thread_proxy_scheduler = false;
 
   if (command_line->HasSwitch(
           switches::kEnableAndroidCompositorAnimationTimelines))
     settings.use_compositor_animation_timelines = true;
 
   cc::LayerTreeHost::InitParams params;
   params.client = this;
   params.shared_bitmap_manager = HostSharedBitmapManager::current();
   params.gpu_memory_buffer_manager = BrowserGpuMemoryBufferManager::current();
   params.task_graph_runner = g_task_graph_runner.Pointer();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
   params.settings = &settings;
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
+  host_->SetVisible(false);
   host_->SetRootLayer(root_layer_);
-
-  host_->SetVisible(true);
   host_->SetLayerTreeHostClientReady();
   host_->SetViewportSize(size_);
   host_->set_has_transparent_background(has_transparent_background_);
   host_->SetDeviceScaleFactor(device_scale_factor_);
 
   if (needs_animate_)
     host_->SetNeedsAnimate();
 }
 
 void CompositorImpl::SetVisible(bool visible) {
   TRACE_EVENT1("cc", "CompositorImpl::SetVisible", "visible", visible);
   if (!visible) {
-    DCHECK(host_);
+    DCHECK(host_->visible());
     // Look for any layers that were attached to the root for readback
     // and are waiting for Composite() to happen.
     bool readback_pending = false;
     for (size_t i = 0; i < root_layer_->children().size(); ++i) {
       if (root_layer_->children()[i]->HasCopyRequest()) {
         readback_pending = true;
         break;
       }
     }
     if (readback_pending) {
-      ignore_schedule_composite_ = true;
+      base::AutoReset<bool> auto_reset_ignore_schedule(
+          &ignore_schedule_composite_, true);
       host_->Composite(base::TimeTicks::Now());
-      ignore_schedule_composite_ = false;
     }
     if (WillComposite())
       CancelComposite();
-    ui_resource_provider_.SetLayerTreeHost(NULL);
-    host_.reset();
+    host_->SetVisible(false);
+    if (!host_->output_surface_lost())
+      host_->ReleaseOutputSurface();
+    pending_swapbuffers_ = 0;
+    needs_composite_ = false;
+    composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
     establish_gpu_channel_timeout_.Stop();
-    output_surface_request_pending_ = false;
     display_client_.reset();
     if (current_composite_task_) {
       current_composite_task_->Cancel();
       current_composite_task_.reset();
     }
-  } else if (!host_) {
-    CreateLayerTreeHost();
-    ui_resource_provider_.SetLayerTreeHost(host_.get());
+  } else {
+    host_->SetVisible(true);
+    if (output_surface_request_pending_)
+      RequestNewOutputSurface();
+    SetNeedsComposite();
   }
 }
 
 void CompositorImpl::setDeviceScaleFactor(float factor) {
   device_scale_factor_ = factor;
   if (host_)
     host_->SetDeviceScaleFactor(factor);
 }
 
 void CompositorImpl::SetWindowBounds(const gfx::Size& size) {
   if (size_ == size)
     return;
 
   size_ = size;
   if (host_)
     host_->SetViewportSize(size);
   if (display_client_)
     display_client_->display()->Resize(size);
   root_layer_->SetBounds(size);
 }
 
 void CompositorImpl::SetHasTransparentBackground(bool flag) {
   has_transparent_background_ = flag;
   if (host_)
     host_->set_has_transparent_background(flag);
 }
 
 void CompositorImpl::SetNeedsComposite() {
-  if (!host_.get())
+  if (!host_->visible())
     return;
   DCHECK(!needs_composite_ || WillComposite());
 
   needs_composite_ = true;
   PostComposite(COMPOSITE_IMMEDIATELY);
 }
 
 static scoped_ptr<WebGraphicsContext3DCommandBufferImpl>
 CreateGpuProcessViewContext(
     const scoped_refptr<GpuChannelHost>& gpu_channel_host,
@@ skipping 18 matching lines @@
       new WebGraphicsContext3DCommandBufferImpl(surface_id,
                                                 url,
                                                 gpu_channel_host.get(),
                                                 attributes,
                                                 lose_context_when_out_of_memory,
                                                 limits,
                                                 NULL));
 }
 
 void CompositorImpl::Layout() {
-  ignore_schedule_composite_ = true;
+  base::AutoReset<bool> auto_reset_ignore_schedule(&ignore_schedule_composite_,
+                                                   true);
   client_->Layout();
-  ignore_schedule_composite_ = false;
 }
 
 void CompositorImpl::OnGpuChannelEstablished() {
   establish_gpu_channel_timeout_.Stop();
   CreateOutputSurface();
 }
 
 void CompositorImpl::OnGpuChannelTimeout() {
   LOG(FATAL) << "Timed out waiting for GPU channel.";
 }
@@ skipping 31 matching lines @@
 
 void CompositorImpl::DidFailToInitializeOutputSurface() {
   LOG(ERROR) << "Failed to init OutputSurface for compositor.";
   LOG_IF(FATAL, ++num_successive_context_creation_failures_ >= 2)
       << "Too many context creation failures. Giving up... ";
   RequestNewOutputSurface();
 }
 
 void CompositorImpl::CreateOutputSurface() {
   // We might have had a request from a LayerTreeHost that was then
-  // deleted.
-  if (!output_surface_request_pending_)
+  // hidden (and hidden means we don't have a native surface).
+  // Also make sure we only handle this once.
+  if (!output_surface_request_pending_ || !host_->visible())
     return;
 
   blink::WebGraphicsContext3D::Attributes attrs;
   attrs.shareResources = true;
   attrs.noAutomaticFlushes = true;
   pending_swapbuffers_ = 0;
 
   DCHECK(window_);
   DCHECK(surface_id_);
 
@@ skipping 31 matching lines @@
     surface_output_surface->set_display_client(display_client_.get());
     display_client_->display()->Resize(size_);
     host_->SetOutputSurface(surface_output_surface.Pass());
   } else {
     host_->SetOutputSurface(real_output_surface.Pass());
   }
 }
 
 void CompositorImpl::PopulateGpuCapabilities(
     gpu::Capabilities gpu_capabilities) {
-  ui_resource_provider_.SetSupportsETC1NonPowerOfTwo(
-      gpu_capabilities.texture_format_etc1_npot);
+  gpu_capabilities_ = gpu_capabilities;
 }
 
 void CompositorImpl::AddObserver(VSyncObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void CompositorImpl::RemoveObserver(VSyncObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
+cc::UIResourceId CompositorImpl::CreateUIResource(
+    cc::UIResourceClient* client) {
+  return host_->CreateUIResource(client);
+}
+
+void CompositorImpl::DeleteUIResource(cc::UIResourceId resource_id) {
+  host_->DeleteUIResource(resource_id);
+}
+
+bool CompositorImpl::SupportsETC1NonPowerOfTwo() const {
+  return gpu_capabilities_.texture_format_etc1_npot;
+}
+
 void CompositorImpl::ScheduleComposite() {
-  DCHECK(!needs_composite_ || WillComposite());
-  if (ignore_schedule_composite_)
+  if (ignore_schedule_composite_ || !host_->visible())
     return;
 
+  DCHECK_IMPLIES(needs_composite_, WillComposite());
   needs_composite_ = true;
   // We currently expect layer tree invalidations at most once per frame
   // during normal operation and therefore try to composite immediately
   // to minimize latency.
   PostComposite(COMPOSITE_IMMEDIATELY);
 }
 
 void CompositorImpl::ScheduleAnimation() {
-  DCHECK(!needs_composite_ || WillComposite());
   needs_animate_ = true;
 
-  if (needs_composite_)
+  if (!host_->visible())
     return;
 
+  if (needs_composite_) {
+    DCHECK(WillComposite());
+    return;
+  }
+
   TRACE_EVENT0("cc", "CompositorImpl::ScheduleAnimation");
   needs_composite_ = true;
   PostComposite(COMPOSITE_EVENTUALLY);
 }
 
 void CompositorImpl::DidPostSwapBuffers() {
   TRACE_EVENT0("compositor", "CompositorImpl::DidPostSwapBuffers");
   did_post_swapbuffers_ = true;
 }
 
@@ skipping 48 matching lines @@
     composite_on_vsync_trigger_ = DO_NOT_COMPOSITE;
     PostComposite(trigger);
   }
 
   FOR_EACH_OBSERVER(VSyncObserver, observer_list_,
                     OnUpdateVSyncParameters(frame_time, vsync_period));
 }
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
-  if (!host_)
+  if (!host_->visible())
     return;
 
   host_->SetNeedsAnimate();
 }
 
 }  // namespace content