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_)

[dneto, 2014/08/15 17:44:31]

Case #4 in LayerTreeHostContextTestLostContextSucceeds required this guard.  It
says "Losing the context and recreating it any number of time should succeed".  
It triggers a Commit 10 times in a row while calling this LoseContext() call in
the middle of the commit.  With the changes to STP::DoCommit, this pointer is
already NULL and without the guard we will crash on a null pointer exception.
I think this guard keeps the spirit of the test because the context will still
be gone after the call to LoseContext terminates.

+      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 15 matching lines @@
     if (delegating_renderer())
       return FakeOutputSurface::CreateDelegating3d(context3d.Pass());
     else
       return FakeOutputSurface::Create3d(context3d.Pass());
   }
 
   virtual DrawResult PrepareToDrawOnThread(
       LayerTreeHostImpl* host_impl,
       LayerTreeHostImpl::FrameData* frame,
       DrawResult draw_result) OVERRIDE {
-    EXPECT_EQ(DRAW_SUCCESS, draw_result);
+    EXPECT_TRUE((DRAW_SUCCESS == draw_result) ||
+                (DRAW_ABORTED_CONTEXT_LOST == draw_result));
     if (!times_to_lose_during_draw_)
       return draw_result;
 
     --times_to_lose_during_draw_;
     LoseContext();
 
     times_to_fail_create_ = times_to_fail_recreate_;
     times_to_fail_recreate_ = 0;
 
     return draw_result;
@@ skipping 536 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:

[dneto, 2014/08/15 17:44:31]

The remaining changes to this file are a result of different scheduling of the
DoCommit.

+        // The single thread proxy issues extra commits after context lost.
+        // http://crbug.com/287250

[danakj, 2014/08/15 17:45:15]

FYI enne this will go away with your Scheduler CL again.

+        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:
         // 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/15 17:45:15]

where's 6? should it be the same as case 5?

         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());
+        // In the single threaded case, the layer tree host finishes committing
+        // before it is notified of surface loss.
+        if (HasImplThread()) {
+          EXPECT_EQ(2u, layer_->output_surface_created_count());
+        } else {
+          EXPECT_EQ(1u, layer_->output_surface_created_count());
+        }
         layer_tree_host()->SetNeedsCommit();
         break;
+      case 5:
+        if (!HasImplThread()) {
+          EXPECT_EQ(2u, layer_->output_surface_created_count());
+          layer_tree_host()->SetNeedsCommit();
+        }
+        break;
+      case 6:
+        if (HasImplThread())
+          NOTREACHED();
+        break;
+      case 7:
+        NOTREACHED();
+        break;
     }
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     LayerTreeHostContextTest::CommitCompleteOnThread(impl);
     switch (LastCommittedSourceFrameNumber(impl)) {
       case 0:
         break;
       case 1:
         break;
       case 2:
         LoseContext();
         break;
       case 3:
-        EndTest();
+        if (HasImplThread())
+          EndTest();
+      case 4:
+        break;
+      case 5:
+        if (!HasImplThread())
+          EndTest();
         break;
     }
   }
 
   virtual void AfterTest() OVERRIDE {}
 
  protected:
   FakeContentLayerClient client_;
   scoped_refptr<FakeContentLayer> layer_;
 };
@@ skipping 54 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