Android: Don't destroy LayerTreeHost when Surface goes away

content/browser/renderer_host/compositor_impl_android.cc

Index: content/browser/renderer_host/compositor_impl_android.cc
diff --git a/content/browser/renderer_host/compositor_impl_android.cc b/content/browser/renderer_host/compositor_impl_android.cc
index f4ae15040b2285108164a1c5076ed356efc13906..b554f9f76a4eba443840ff0860a51a07aa9fa97f 100644
--- a/content/browser/renderer_host/compositor_impl_android.cc
+++ b/content/browser/renderer_host/compositor_impl_android.cc
@@ -230,7 +230,7 @@ scoped_ptr<cc::SurfaceIdAllocator> CompositorImpl::CreateSurfaceIdAllocator() {
 CompositorImpl::CompositorImpl(CompositorClient* client,
                                gfx::NativeWindow root_window)
     : root_layer_(cc::Layer::Create(Compositor::LayerSettings())),
-      resource_manager_(&ui_resource_provider_),
+      resource_manager_,
       surface_id_allocator_(GetSurfaceManager() ? CreateSurfaceIdAllocator()
                                                 : nullptr),
       has_transparent_background_(false),
@@ -252,6 +252,8 @@ CompositorImpl::CompositorImpl(CompositorClient* client,
   DCHECK(client);
   DCHECK(root_window);
   root_window->AttachCompositor(this);
+  CreateLayerTreeHost();
+  resource_manager_.Init(host_.get());
 }
 
 CompositorImpl::~CompositorImpl() {
@@ -324,7 +326,7 @@ 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());
@@ -369,7 +371,7 @@ void CompositorImpl::Composite(CompositingTrigger trigger) {
 }
 
 ui::UIResourceProvider& CompositorImpl::GetUIResourceProvider() {
-  return ui_resource_provider_;
+  return *this;
 }
 
 ui::ResourceManager& CompositorImpl::GetResourceManager() {
@@ -440,8 +442,6 @@ void CompositorImpl::SetSurface(jobject surface) {
 void CompositorImpl::CreateLayerTreeHost() {
   DCHECK(!host_);
   DCHECK(!WillCompositeThisFrame());
-  needs_composite_ = false;
-  pending_swapbuffers_ = 0;
   cc::LayerTreeSettings settings;
   settings.renderer_settings.refresh_rate = 60.0;
   settings.renderer_settings.allow_antialiasing = false;
@@ -469,8 +469,7 @@ void CompositorImpl::CreateLayerTreeHost() {
   params.settings = &settings;
   host_ = cc::LayerTreeHost::CreateSingleThreaded(this, &params);
   host_->SetRootLayer(root_layer_);
-
-  host_->SetVisible(true);
+  host_->SetVisible(false);
   host_->SetLayerTreeHostClientReady();
   host_->SetViewportSize(size_);
   host_->set_has_transparent_background(has_transparent_background_);
@@ -483,7 +482,7 @@ void CompositorImpl::CreateLayerTreeHost() {
 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;
@@ -500,8 +499,10 @@ void CompositorImpl::SetVisible(bool visible) {
     }
     if (WillComposite())
       CancelComposite();
-    ui_resource_provider_.SetLayerTreeHost(NULL);
-    host_.reset();
+    host_->SetVisible(false);
+    host_->ReleaseOutputSurface();
+    pending_swapbuffers_ = 0;
+    needs_composite_ = false;
     establish_gpu_channel_timeout_.Stop();
     output_surface_request_pending_ = false;
     display_client_.reset();
@@ -509,9 +510,9 @@ void CompositorImpl::SetVisible(bool visible) {
       current_composite_task_->Cancel();
       current_composite_task_.reset();
     }
-  } else if (!host_) {
-    CreateLayerTreeHost();
-    ui_resource_provider_.SetLayerTreeHost(host_.get());
+  } else {
+    host_->SetVisible(true);
+    SetNeedsComposite();
   }
 }
 
@@ -540,7 +541,7 @@ void CompositorImpl::SetHasTransparentBackground(bool flag) {
 }
 
 void CompositorImpl::SetNeedsComposite() {
-  if (!host_.get())
+  if (!host_->visible())
     return;
   DCHECK(!needs_composite_ || WillComposite());
 
@@ -686,8 +687,7 @@ void CompositorImpl::CreateOutputSurface() {
 
 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) {
@@ -698,11 +698,24 @@ 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
@@ -711,7 +724,7 @@ void CompositorImpl::ScheduleComposite() {
 }
 
 void CompositorImpl::ScheduleAnimation() {
-  DCHECK(!needs_composite_ || WillComposite());
+  DCHECK_IMPLIES(needs_composite_, WillComposite());
   needs_animate_ = true;
 
   if (needs_composite_)
@@ -785,7 +798,7 @@ void CompositorImpl::OnVSync(base::TimeTicks frame_time,
 
 void CompositorImpl::SetNeedsAnimate() {
   needs_animate_ = true;
-  if (!host_)
+  if (!host_->visible())
     return;
 
   host_->SetNeedsAnimate();