blimp/engine/renderer/blimp_remote_compositor_bridge_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 "blimp/engine/renderer/blimp_remote_compositor_bridge.h"

#include "base/memory/ptr_util.h"
#include "base/run_loop.h"
#include "base/threading/thread_task_runner_handle.h"
#include "cc/blimp/compositor_proto_state.h"
#include "cc/blimp/remote_compositor_bridge_client.h"
#include "cc/proto/compositor_message.pb.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace blimp {
namespace engine {
namespace {

class BlimpRemoteCompositorBridgeTest : public testing::Test,
                                        public cc::RemoteCompositorBridgeClient,
                                        public content::RemoteProtoChannel {
 public:
  BlimpRemoteCompositorBridgeTest() = default;
  ~BlimpRemoteCompositorBridgeTest() override = default;

  void SetUp() override {
    remote_compositor_bridge_ = base::MakeUnique<BlimpRemoteCompositorBridge>(
        this, base::ThreadTaskRunnerHandle::Get());
    DCHECK(proto_receiver_);

    remote_compositor_bridge_->BindToClient(this);
    remote_compositor_bridge_->scheduler_for_testing()
        ->set_frame_delay_for_testing(base::TimeDelta::FromSeconds(0));
  }
  void TearDown() override {
    remote_compositor_bridge_ = nullptr;
    DCHECK(!proto_receiver_);
  }

  // RemoteProtoChannel implementation.
  void SetProtoReceiver(ProtoReceiver* receiver) override {
    DCHECK(!proto_receiver_ || !receiver);
    proto_receiver_ = receiver;
  }
  void SendCompositorProto(const cc::proto::CompositorMessage& proto) override {
    if (proto.has_layer_tree_host())
      num_of_frames_sent_++;
    if (proto.has_client_state_update_ack())
      num_of_client_state_acks_sent_++;
  }

  // cc::RemoteCompositorBridgeClient implementation.
  void BeginMainFrame() override {
    if (send_frame_) {
      std::unique_ptr<cc::CompositorProtoState> proto_state =
          base::MakeUnique<cc::CompositorProtoState>();
      proto_state->compositor_message =
          base::MakeUnique<cc::proto::CompositorMessage>();
      proto_state->compositor_message->mutable_layer_tree_host()
          ->mutable_layer_tree()
          ->set_page_scale_factor(1.f);

      send_frame_ = false;
      remote_compositor_bridge_->ProcessCompositorStateUpdate(
          std::move(proto_state));
    }
  }
  void ApplyStateUpdateFromClient(
      const cc::proto::ClientStateUpdate& client_state_update) override {
    num_of_client_updates_++;
  }

  int num_of_frames_sent() const { return num_of_frames_sent_; }
  int num_of_client_state_acks_sent() const {
    return num_of_client_state_acks_sent_;
  }
  int num_of_client_updates() const { return num_of_client_updates_; }

  void set_send_frame(bool send_frame) { send_frame_ = send_frame; }

  void SendFrameAck() {
    std::unique_ptr<cc::proto::CompositorMessage> message =
        base::MakeUnique<cc::proto::CompositorMessage>();
    message->set_frame_ack(true);
    proto_receiver_->OnProtoReceived(std::move(message));
  }

  void SendClientStateUpdate() {
    std::unique_ptr<cc::proto::CompositorMessage> message =
        base::MakeUnique<cc::proto::CompositorMessage>();
    message->mutable_client_state_update()->set_page_scale_delta(0.2f);
    proto_receiver_->OnProtoReceived(std::move(message));
  }

 protected:
  base::MessageLoop loop_;
  std::unique_ptr<BlimpRemoteCompositorBridge> remote_compositor_bridge_;
  content::RemoteProtoChannel::ProtoReceiver* proto_receiver_ = nullptr;

 private:
  int num_of_frames_sent_ = 0;
  int num_of_client_state_acks_sent_ = 0;
  int num_of_client_updates_ = 0;
  bool send_frame_ = false;
};

TEST_F(BlimpRemoteCompositorBridgeTest, FrameAndFrameAck) {
  // Request a frame with an update.
  set_send_frame(true);
  remote_compositor_bridge_->ScheduleMainFrame();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(1, num_of_frames_sent());

  // Request another frame while the previous one has not been acked.
  set_send_frame(true);
  remote_compositor_bridge_->ScheduleMainFrame();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(1, num_of_frames_sent());

  // Ack the previous frame and ensure that the next frame is run.
  SendFrameAck();
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(2, num_of_frames_sent());
}

TEST_F(BlimpRemoteCompositorBridgeTest, ClientStateUpdateAck) {
  // Send a client state update with no frame requests present. We should see
  // an ack immediately
  SendClientStateUpdate();
  EXPECT_EQ(1, num_of_client_updates());
  EXPECT_EQ(1, num_of_client_state_acks_sent());

  // Request a frame with no update, the ack should come after the frame runs.
  remote_compositor_bridge_->ScheduleMainFrame();
  SendClientStateUpdate();
  EXPECT_EQ(2, num_of_client_updates());
  EXPECT_EQ(1, num_of_client_state_acks_sent());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(2, num_of_client_state_acks_sent());

  // Request a frame with an update, the ack should be bundled with the frame.
  set_send_frame(true);
  remote_compositor_bridge_->ScheduleMainFrame();
  SendClientStateUpdate();
  EXPECT_EQ(3, num_of_client_updates());
  EXPECT_EQ(2, num_of_client_state_acks_sent());
  EXPECT_EQ(0, num_of_frames_sent());
  base::RunLoop().RunUntilIdle();
  EXPECT_EQ(3, num_of_client_state_acks_sent());
  EXPECT_EQ(1, num_of_frames_sent());
}

}  // namespace
}  // namespace engine
}  // namespace blimp