cc/debug/micro_benchmark_controller_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/callback.h"
   6 #include "base/memory/scoped_ptr.h"
   7 #include "cc/debug/micro_benchmark.h"
   8 #include "cc/debug/micro_benchmark_controller.h"
   9 #include "cc/layers/layer.h"
  10 #include "cc/resources/resource_update_queue.h"
  11 #include "cc/test/fake_layer_tree_host.h"
  12 #include "cc/test/fake_layer_tree_host_impl.h"
  13 #include "cc/test/fake_proxy.h"
  14 #include "testing/gtest/include/gtest/gtest.h"
  15
  16 namespace cc {
  17 namespace {
  18
  19 class MicroBenchmarkControllerTest : public testing::Test {
  20  public:
  21   MicroBenchmarkControllerTest()
  22       : layer_tree_host_client_(FakeLayerTreeHostClient::DIRECT_3D) {}
  23
  24   void SetUp() override {
  25     impl_proxy_ = make_scoped_ptr(new FakeImplProxy);
  26     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
  27     layer_tree_host_impl_ = make_scoped_ptr(new FakeLayerTreeHostImpl(
  28         impl_proxy_.get(), shared_bitmap_manager_.get(), nullptr));
  29
  30     layer_tree_host_ = FakeLayerTreeHost::Create(&layer_tree_host_client_);
  31     layer_tree_host_->SetRootLayer(Layer::Create());
  32     layer_tree_host_->InitializeForTesting(scoped_ptr<Proxy>(new FakeProxy));
  33   }
  34
  35   void TearDown() override {
  36     layer_tree_host_impl_ = nullptr;
  37     layer_tree_host_ = nullptr;
  38     impl_proxy_ = nullptr;
  39   }
  40
  41   FakeLayerTreeHostClient layer_tree_host_client_;
  42   scoped_ptr<FakeLayerTreeHost> layer_tree_host_;
  43   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
  44   scoped_ptr<FakeLayerTreeHostImpl> layer_tree_host_impl_;
  45   scoped_ptr<FakeImplProxy> impl_proxy_;
  46 };
  47
  48 void Noop(scoped_ptr<base::Value> value) {
  49 }
  50
  51 void IncrementCallCount(int* count, scoped_ptr<base::Value> value) {
  52   ++(*count);
  53 }
  54
  55 TEST_F(MicroBenchmarkControllerTest, ScheduleFail) {
  56   int id = layer_tree_host_->ScheduleMicroBenchmark(
  57       "non_existant_benchmark", nullptr, base::Bind(&Noop));
  58   EXPECT_EQ(id, 0);
  59 }
  60
  61 TEST_F(MicroBenchmarkControllerTest, CommitScheduled) {
  62   EXPECT_FALSE(layer_tree_host_->needs_commit());
  63   int id = layer_tree_host_->ScheduleMicroBenchmark(
  64       "unittest_only_benchmark", nullptr, base::Bind(&Noop));
  65   EXPECT_GT(id, 0);
  66   EXPECT_TRUE(layer_tree_host_->needs_commit());
  67 }
  68
  69 TEST_F(MicroBenchmarkControllerTest, BenchmarkRan) {
  70   int run_count = 0;
  71   int id = layer_tree_host_->ScheduleMicroBenchmark(
  72       "unittest_only_benchmark",
  73       nullptr,
  74       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
  75   EXPECT_GT(id, 0);
  76
  77   scoped_ptr<ResourceUpdateQueue> queue(new ResourceUpdateQueue);
  78   layer_tree_host_->SetOutputSurfaceLostForTesting(false);
  79   layer_tree_host_->UpdateLayers(queue.get());
  80
  81   EXPECT_EQ(1, run_count);
  82 }
  83
  84 TEST_F(MicroBenchmarkControllerTest, MultipleBenchmarkRan) {
  85   int run_count = 0;
  86   int id = layer_tree_host_->ScheduleMicroBenchmark(
  87       "unittest_only_benchmark",
  88       nullptr,
  89       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
  90   EXPECT_GT(id, 0);
  91   id = layer_tree_host_->ScheduleMicroBenchmark(
  92       "unittest_only_benchmark",
  93       nullptr,
  94       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
  95   EXPECT_GT(id, 0);
  96
  97   scoped_ptr<ResourceUpdateQueue> queue(new ResourceUpdateQueue);
  98   layer_tree_host_->SetOutputSurfaceLostForTesting(false);
  99   layer_tree_host_->UpdateLayers(queue.get());
 100
 101   EXPECT_EQ(2, run_count);
 102
 103   id = layer_tree_host_->ScheduleMicroBenchmark(
 104       "unittest_only_benchmark",
 105       nullptr,
 106       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
 107   EXPECT_GT(id, 0);
 108   id = layer_tree_host_->ScheduleMicroBenchmark(
 109       "unittest_only_benchmark",
 110       nullptr,
 111       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
 112   EXPECT_GT(id, 0);
 113
 114   layer_tree_host_->UpdateLayers(queue.get());
 115   EXPECT_EQ(4, run_count);
 116
 117   layer_tree_host_->UpdateLayers(queue.get());
 118   EXPECT_EQ(4, run_count);
 119 }
 120
 121 TEST_F(MicroBenchmarkControllerTest, BenchmarkImplRan) {
 122   int run_count = 0;
 123   scoped_ptr<base::DictionaryValue> settings(new base::DictionaryValue);
 124   settings->SetBoolean("run_benchmark_impl", true);
 125
 126   // Schedule a main thread benchmark.
 127   int id = layer_tree_host_->ScheduleMicroBenchmark(
 128       "unittest_only_benchmark",
 129       settings.Pass(),
 130       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
 131   EXPECT_GT(id, 0);
 132
 133   // Schedule impl benchmarks. In production code, this is run in commit.
 134   layer_tree_host_->GetMicroBenchmarkController()->ScheduleImplBenchmarks(
 135       layer_tree_host_impl_.get());
 136
 137   // Now complete the commit (as if on the impl thread).
 138   layer_tree_host_impl_->CommitComplete();
 139
 140   // Make sure all posted messages run.
 141   base::MessageLoop::current()->RunUntilIdle();
 142
 143   EXPECT_EQ(1, run_count);
 144 }
 145
 146 TEST_F(MicroBenchmarkControllerTest, SendMessage) {
 147   // Send valid message to invalid benchmark (id = 0)
 148   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue);
 149   message->SetBoolean("can_handle", true);
 150   bool message_handled =
 151       layer_tree_host_->SendMessageToMicroBenchmark(0, message.Pass());
 152   EXPECT_FALSE(message_handled);
 153
 154   // Schedule a benchmark
 155   int run_count = 0;
 156   int id = layer_tree_host_->ScheduleMicroBenchmark(
 157       "unittest_only_benchmark",
 158       nullptr,
 159       base::Bind(&IncrementCallCount, base::Unretained(&run_count)));
 160   EXPECT_GT(id, 0);
 161
 162   // Send valid message to valid benchmark
 163   message = make_scoped_ptr(new base::DictionaryValue);
 164   message->SetBoolean("can_handle", true);
 165   message_handled =
 166       layer_tree_host_->SendMessageToMicroBenchmark(id, message.Pass());
 167   EXPECT_TRUE(message_handled);
 168
 169   // Send invalid message to valid benchmark
 170   message = make_scoped_ptr(new base::DictionaryValue);
 171   message->SetBoolean("can_handle", false);
 172   message_handled =
 173       layer_tree_host_->SendMessageToMicroBenchmark(id, message.Pass());
 174   EXPECT_FALSE(message_handled);
 175 }
 176
 177 }  // namespace
 178 }  // namespace cc