Remove cc::LayerTreeHostImpl::IsContextLost

cc/trees/layer_tree_host_unittest_context.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include "base/basictypes.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/delegated_frame_provider.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
@@ skipping 47 matching lines @@
         times_to_fail_recreate_(0),
         times_to_expect_create_failed_(0),
         times_create_failed_(0),
         committed_at_least_once_(false),
         context_should_support_io_surface_(false),
         fallback_context_works_(false) {
     media::InitializeMediaLibraryForTesting();
   }
 
   void LoseContext() {
+    if (!context3d_)

[danakj, 2014/08/20 18:22:10]

Is this still needed?

[dneto, 2014/08/20 19:15:20]

Yes.  Otherwise 6 tests crash with null ptr exception.  The STP::DoCommit calls
CommitComplete hook which in some tests calls LoseContext a second time when we
haven't yet recovered from context loss.

These tests are:
   
LayerTreeHostContextTestLostContextAndEvictTextures.LoseBeforeEvict_SingleThread_DelegatingRenderer
   
LayerTreeHostContextTestLostContextAndEvictTextures.LoseBeforeEvict_SingleThread_DirectRenderer
   
LayerTreeHostContextTestLostContextSucceeds.RunSingleThread_DelegatingRenderer
    LayerTreeHostContextTestLostContextSucceeds.RunSingleThread_DirectRenderer
   
LayerTreeHostContextTestLostContextSucceedsWithContent.RunSingleThread_DelegatingRenderer
   
LayerTreeHostContextTestLostContextSucceedsWithContent.RunSingleThread_DirectRenderer

+      return;
     context3d_->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
                                     GL_INNOCENT_CONTEXT_RESET_ARB);
     context3d_ = NULL;
   }
 
   virtual scoped_ptr<TestWebGraphicsContext3D> CreateContext3d() {
     return TestWebGraphicsContext3D::Create();
   }
 
   virtual scoped_ptr<FakeOutputSurface> CreateFakeOutputSurface(bool fallback)
@@ skipping 509 matching lines @@
       parent_->AddChild(child);
     }
 
     layer_tree_host()->SetRootLayer(parent_);
     LayerTreeHostContextTest::SetupTree();
   }
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* host_impl) OVERRIDE {
-    EXPECT_EQ(0, times_to_lose_on_end_query_);
+    // In the multi-thread case, the scheduler sees the context loss and forces
+    // re-creation of the output surface before any drawing is attempted.
+    // In the single-thread case, we still draw even if the context is lost
+    // during resource creation.  The loss will be detected later.
+    if (HasImplThread())
+      EXPECT_EQ(0, times_to_lose_on_end_query_);
     EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
+    // We have recovered from all context losses in both the single- and
+    // multi-threaded cases.
     EXPECT_EQ(0, times_to_lose_on_end_query_);
   }
 
  private:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> parent_;
   int num_children_;
   int times_to_lose_on_end_query_;
 };
 
@@ skipping 38 matching lines @@
         // Lose the context and struggle to recreate it.
         LoseContext();
         times_to_fail_create_ = 1;
         break;
       case 2:
         EXPECT_GE(1u, root->lost_output_surface_count());
         EXPECT_GE(1u, child->lost_output_surface_count());
         EXPECT_GE(1u, grandchild->lost_output_surface_count());
         EndTest();
         break;
+      case 3:

[danakj, 2014/08/20 18:22:10]

did you verify that you still need this extra case?

[dneto, 2014/08/20 19:15:20]

Yes, it's still needed.

+        // The single thread proxy issues extra commits after context lost.
+        // http://crbug.com/287250
+        if (HasImplThread())
+          NOTREACHED();
+        break;
       default:
         NOTREACHED();
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  private:
   int num_commits_;
 
@@ skipping 307 matching lines @@
         EXPECT_EQ(1, scrollbar_layer_->update_count());
         LoseContext();
         break;
       case 2:
         // Second update, after the lost context, we should still upload 2
         // resources even if the contents haven't changed.
         EXPECT_EQ(2, scrollbar_layer_->update_count());
         EndTest();
         break;
       case 3:
+      case 4:

[danakj, 2014/08/20 18:22:10]

did you verify that you still need this extra case?

         // Single thread proxy issues extra commits after context lost.
         // http://crbug.com/287250
         if (HasImplThread())
           NOTREACHED();
         break;
       default:
         NOTREACHED();
     }
   }
 
@@ skipping 93 matching lines @@
         // Release resource before ending the test.
         ui_resource_.reset();
         EndTest();
         break;
       case 5:
         // Single thread proxy issues extra commits after context lost.
         // http://crbug.com/287250
         if (HasImplThread())
           NOTREACHED();
         break;
-      case 6:
+      case 7:

[danakj, 2014/08/20 18:22:10]

case 6? or should case 6 be up with case 5?

[dneto, 2014/08/20 19:15:20]

Single thread case does reach case 6, so changing 7 --> 6 causes failure.

The multi-thread case never goes past 5, only single-thread does.  I don't think
it adds anything to make 5 and 6 the same.

[danakj, 2014/08/20 19:19:12]

Ah ok, since we don't reach 5 we won't reach 6, sure.

         NOTREACHED();
     }
   }
 
   virtual void StepCompleteOnImplThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (time_step_) {
       case 1:
         // The resource should have been created on LTHI after the commit.
         EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
         PostSetNeedsCommitToMainThread();
         break;
       case 2:
         LoseContext();
         break;
       case 3:
-        // The resources should have been recreated. The bitmap callback should
-        // have been called once with the resource_lost flag set to true.
-        EXPECT_EQ(1, ui_resource_->lost_resource_count);
-        // Resource Id on the impl-side have been recreated as well. Note
-        // that the same UIResourceId persists after the context lost.
-        EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
-        PostSetNeedsCommitToMainThread();
+        if (HasImplThread())
+          CheckForLossRecoveryThenContinue(impl);
+        break;
+      case 4:
+        // In the single-threaded case, the layer tree host sees the
+        // loss one step later.
+        if (!HasImplThread())
+          CheckForLossRecoveryThenContinue(impl);
         break;
     }
   }
+
+  void CheckForLossRecoveryThenContinue(LayerTreeHostImpl* impl) {
+    // The resources should have been recreated. The bitmap callback should
+    // have been called once with the resource_lost flag set to true.
+    EXPECT_EQ(1, ui_resource_->lost_resource_count);
+    // The resource id on the impl-side should have been recreated as well.
+    // Note that the same UIResourceId persists after the context is lost.
+    EXPECT_NE(0u, impl->ResourceIdForUIResource(ui_resource_->id()));
+    PostSetNeedsCommitToMainThread();
+  }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(UIResourceLostAfterCommit);
 
 // Losing context before UI resource requests can be commited.  Three sequences
 // of creation/deletion are considered:
 // 1. Create one resource -> Context Lost => Expect the resource to have been
 // created.
 // 2. Delete an exisiting resource (test_id0_) -> create a second resource
 // (test_id1_) -> Context Lost => Expect the test_id0_ to be removed and
@@ skipping 306 matching lines @@
         layer_tree_host()->SetNeedsCommit();
         break;
       case 2:
         EXPECT_EQ(1u, layer_->output_surface_created_count());
         layer_tree_host()->SetNeedsCommit();
         break;
       case 3:
         EXPECT_EQ(1u, layer_->output_surface_created_count());
         break;
       case 4:
-        EXPECT_EQ(2u, layer_->output_surface_created_count());
-        layer_tree_host()->SetNeedsCommit();
+        if (HasImplThread()) {
+          EXPECT_EQ(2u, layer_->output_surface_created_count());
+          layer_tree_host()->SetNeedsCommit();
+        }
+        break;
+      case 5:
+        // The single thread proxy notices the context is lost after the commit
+        // has completed.
+        if (!HasImplThread()) {
+          EXPECT_EQ(2u, layer_->output_surface_created_count());
+          layer_tree_host()->SetNeedsCommit();
+        }
         break;
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (LastCommittedSourceFrameNumber(impl)) {
       case 0:
         break;
       case 1:
@@ skipping 70 matching lines @@
   virtual void AfterTest() OVERRIDE {}
 
   bool deferred_;
 };
 
 // TODO(danakj): We don't use scheduler with SingleThreadProxy yet.
 MULTI_THREAD_TEST_F(LayerTreeHostContextTestLoseAfterSendingBeginMainFrame);
 
 }  // namespace
 }  // namespace cc