cc: Don't make AcquireLayerTextures force a commit.

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 227 matching lines @@
 
   client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 2);
   EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
   EXPECT_FALSE(scheduler->RedrawPending());
   EXPECT_FALSE(client.needs_begin_frame());
 
   client.Reset();
   scheduler->SetMainThreadNeedsLayerTextures();
-  EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
-                client,
-                0,
-                3);
-  // A commit was started by SetMainThreadNeedsLayerTextures().
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 3);
-  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 2, 3);
+  EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
+                       client);
 
   // We should request a BeginFrame in anticipation of a draw.
   client.Reset();
   scheduler->SetNeedsRedraw();
   EXPECT_TRUE(scheduler->RedrawPending());
+  EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_TRUE(client.needs_begin_frame());
 
   // No draw happens since the textures are acquired by the main thread.
   client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_SINGLE_ACTION("SetNeedsBeginFrameOnImplThread", client);
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
+  scheduler->SetNeedsCommit();
+  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 0, 2);
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 1, 2);
+  EXPECT_TRUE(client.needs_begin_frame());
+
   // Commit will release the texture.
   client.Reset();
   scheduler->FinishCommit();
   EXPECT_SINGLE_ACTION("ScheduledActionCommit", client);
   EXPECT_TRUE(scheduler->RedrawPending());
   EXPECT_TRUE(client.needs_begin_frame());
 
   // Now we can draw again after the commit happens.
   client.Reset();
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
@@ skipping 36 matching lines @@
   scheduler->FinishCommit();
   EXPECT_TRUE(client.needs_begin_frame());
   client.Reset();
 
   // Between commit and draw, texture acquisition for main thread delayed,
   // and main thread blocks.
   scheduler->SetMainThreadNeedsLayerTextures();
   EXPECT_EQ(0, client.num_actions_());
   client.Reset();
 
-  // Once compositor draw complete, the delayed texture acquisition fires.
+  // No implicit commit is expected.
   scheduler->BeginFrame(BeginFrameArgs::CreateForTesting());
   EXPECT_ACTION("ScheduledActionDrawAndSwapIfPossible", client, 0, 3);
   EXPECT_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                 client,
                 1,
                 3);
-  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 2, 3);
+  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 2, 3);
   client.Reset();
+
+  // Compositor not scheduled to draw because textures are locked by main
+  // thread.
+  EXPECT_FALSE(client.needs_begin_frame());
+
+  // Needs an explicit commit from the main thread.
+  scheduler->SetNeedsCommit();
+  EXPECT_ACTION("ScheduledActionSendBeginFrameToMainThread", client, 0, 2);
+  EXPECT_ACTION("SetNeedsBeginFrameOnImplThread", client, 1, 2);
+  client.Reset();
+
+  // Trigger the commit
+  scheduler->FinishCommit();
+  EXPECT_TRUE(client.needs_begin_frame());
 }
 
 TEST(SchedulerTest, VisibilitySwitchWithTextureAcquisition) {
   FakeSchedulerClient client;
   SchedulerSettings default_scheduler_settings;
   Scheduler* scheduler = client.CreateScheduler(default_scheduler_settings);
   scheduler->SetCanStart();
   scheduler->SetVisible(true);
   scheduler->SetCanDraw(true);
 
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   client.Reset();
   scheduler->DidCreateAndInitializeOutputSurface();
 
   scheduler->SetNeedsCommit();
   scheduler->FinishCommit();
   scheduler->SetMainThreadNeedsLayerTextures();
+  scheduler->SetNeedsCommit();
   client.Reset();
   // Verify that pending texture acquisition fires when visibility
   // is lost in order to avoid a deadlock.
   scheduler->SetVisible(false);
   EXPECT_SINGLE_ACTION("ScheduledActionAcquireLayerTexturesForMainThread",
                        client);
   client.Reset();
 
   // Regaining visibility with textures acquired by main thread while
   // compositor is waiting for first draw should result in a request
@@ skipping 230 matching lines @@
 
   // Get the compositor to do a ScheduledActionDrawAndSwapForced.
   scheduler->SetCanDraw(true);
   scheduler->SetNeedsRedraw();
   scheduler->SetNeedsForcedRedraw();
   EXPECT_TRUE(client.HasAction("ScheduledActionDrawAndSwapForced"));
 }
 
 }  // namespace
 }  // namespace cc