Fixed a cc unittest for swap buffer change

cc/trees/remote_channel_unittest.cc

 // Copyright 2016 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/test/begin_frame_args_test.h"
 #include "cc/test/layer_tree_test.h"
 
 namespace cc {
 
 class RemoteChannelTest : public LayerTreeTest {
  protected:
-  RemoteChannelTest() : calls_received_(0) {}
+  RemoteChannelTest()
+      : calls_received_(0), calls_received_on_both_server_and_client_(0) {}

[Khushal, 2016/05/06 21:37:54]

How about splitting this into calls_received_on_client_ and
calls_received_on_server_ and using them for each test then?

[shaktisahu, 2016/05/07 00:46:12]

Yea, but it is hard to know if the call is received on client or engine since
the method is identical. In that case, if I do calls_received_on_client_++ and
calls_received_on_server_++, they both would be equal to 2, which is incorrect.

[Khushal, 2016/05/09 09:06:33]

Sorry, I meant we could split it into calls_expected_on_server_only_,
calls_expected_on_client_only_ and calls_expected_on_server_and_client_.

Regarding knowing whether the call was made on the server or client, Its
possible to add a bool to the LayerTreeHostClientForTesting to know whether it
is created for server or client LayerTreeHost and pass it in the TestHooks
callbacks. +vmpstr if that sounds cool.

[vmpstr, 2016/05/10 18:27:32]

I would prefer that we don't have any "server and client" variables, since the
test should know explicitly whether it's a server or a client and verify that
state appropriately. 
Do we have ::CreateForServer or ::CreateForClient functions or something? How
would this look for non-blimp LTHCFT /o\

[Khushal, 2016/05/10 19:11:31]

The LayerTreeTests keep an instance of both the server and client and use a mock
network layer to ship protos between the two. The RemoteChannelTests is
verifying things for both ends.

All the LTHC callbacks reach the tests using TestHooks, so there is not an easy
way to distinctly identify where they came from. :/
Not yet, but that's one way to do it. The threaded tests don't really need that
distinction, so they can just ignore that field. This would require changing all
tests that use this though.

Another option would be for classes extending LayerTreeTests to pass in their
own LTHC for the remote client LTH, which can internally use a mini TestHooks
like class to give the callbacks to the their test. That wouldn't be pretty
either but wouldn't require changing the rest of the tests. Whichever is easier.
. .

Or for this change this is also fine.

 
   ~RemoteChannelTest() override {}
 
   void BeginTest() override {
     DCHECK(IsRemoteTest());
     BeginChannelTest();
   }
   virtual void BeginChannelTest() {}
 
   int calls_received_;
 
+  // Since LayerTreeHost on engine and client share a common LayerTreeHostClient
+  // for unit tests, there are some functions called twice. This variable keep
+  // tracks of those function calls.
+  int calls_received_on_both_server_and_client_;
+
  private:
   DISALLOW_COPY_AND_ASSIGN(RemoteChannelTest);
 };
 
 class RemoteChannelTestInitializationAndShutdown : public RemoteChannelTest {
   void SetVisibleOnImpl(bool visible) override { calls_received_++; }
 
   void RequestNewOutputSurface() override {
     LayerTreeTest::RequestNewOutputSurface();
     calls_received_++;
@@ skipping 99 matching lines @@
 
   void SetNeedsCommitOnImpl() override { EXPECT_EQ(0, calls_received_++); }
 
   void ReceivedBeginMainFrame() override { EXPECT_EQ(1, calls_received_++); }
 
   void StartCommitOnImpl() override { EXPECT_EQ(2, calls_received_++); }
 
   void DidCommitAndDrawFrame() override { EXPECT_EQ(3, calls_received_++); }
 
   void DidCompleteSwapBuffers() override {
-    EXPECT_EQ(4, calls_received_++);
-    EndTest();
+    if (++calls_received_on_both_server_and_client_ == 2)
+      EndTest();
   }
 
   void WillCommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // Ensure that we serialized and deserialized the LayerTreeHost for the
     // commit.
     EXPECT_EQ(viewport_size_, host_impl->device_viewport_size());
   }
 
   void AfterTest() override {
-    EXPECT_EQ(5, calls_received_);
+    EXPECT_EQ(4, calls_received_);
+    EXPECT_EQ(2, calls_received_on_both_server_and_client_);
   }
 
   const gfx::Size viewport_size_ = gfx::Size(5, 3);
 };
 
 REMOTE_DIRECT_RENDERER_TEST_F(RemoteChannelTestCommit);
 
 class RemoteChannelTestBeginMainFrameAborted : public RemoteChannelTest {
   void BeginChannelTest() override { PostSetNeedsCommitToMainThread(); }
 
@@ skipping 52 matching lines @@
   }
 
   int output_surface_initialized_count_;
   int commit_count_;
 };
 
 REMOTE_DIRECT_RENDERER_TEST_F(
     RemoteChannelTestReleaseOutputSurfaceDuringCommit);
 
 }  // namespace cc