gpu/command_buffer/service/command_executor_unittest.cc

// Copyright (c) 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 "gpu/command_buffer/service/command_executor.h"

#include <stddef.h>
#include <stdint.h>

#include <memory>

#include "base/run_loop.h"
#include "gpu/command_buffer/common/command_buffer_mock.h"
#include "gpu/command_buffer/service/gles2_cmd_decoder.h"
#include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
#include "gpu/command_buffer/service/mocks.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

using testing::_;
using testing::DoAll;
using testing::Invoke;
using testing::NiceMock;
using testing::Return;
using testing::SetArgumentPointee;
using testing::StrictMock;

namespace gpu {

const size_t kRingBufferSize = 1024;

class CommandExecutorTest : public testing::Test {
 protected:
  static const int32_t kTransferBufferId = 123;

  void SetUp() override {
    std::unique_ptr<base::SharedMemory> shared_memory(new ::base::SharedMemory);
    shared_memory->CreateAndMapAnonymous(kRingBufferSize);
    buffer_ = static_cast<int32_t*>(shared_memory->memory());
    shared_memory_buffer_ =
        MakeBufferFromSharedMemory(std::move(shared_memory), kRingBufferSize);
    memset(buffer_, 0, kRingBufferSize);

    command_buffer_.reset(new MockCommandBuffer);

    CommandBuffer::State default_state;
    ON_CALL(*command_buffer_.get(), GetLastState())
        .WillByDefault(Return(default_state));
    ON_CALL(*command_buffer_.get(), GetPutOffset()).WillByDefault(Return(0));

    decoder_.reset(new gles2::MockGLES2Decoder());
    // Install FakeDoCommands handler so we can use individual DoCommand()
    // expectations.
    EXPECT_CALL(*decoder_, DoCommands(_, _, _, _))
        .WillRepeatedly(
            Invoke(decoder_.get(), &gles2::MockGLES2Decoder::FakeDoCommands));

    executor_.reset(new gpu::CommandExecutor(command_buffer_.get(),
                                             decoder_.get(), decoder_.get()));
    EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId))
        .WillOnce(Return(shared_memory_buffer_));
    EXPECT_CALL(*command_buffer_, SetGetOffset(0));
    EXPECT_TRUE(executor_->SetGetBuffer(kTransferBufferId));
  }

  void TearDown() override {
    // Ensure that any unexpected tasks posted by the GPU scheduler are executed
    // in order to fail the test.
    base::RunLoop().RunUntilIdle();
  }

  error::Error GetError() { return command_buffer_->GetLastState().error; }

  std::unique_ptr<MockCommandBuffer> command_buffer_;
  scoped_refptr<Buffer> shared_memory_buffer_;
  int32_t* buffer_;
  std::unique_ptr<gles2::MockGLES2Decoder> decoder_;
  std::unique_ptr<CommandExecutor> executor_;
  base::MessageLoop message_loop_;
};

TEST_F(CommandExecutorTest, ExecutorDoesNothingIfRingBufferIsEmpty) {
  CommandBuffer::State state;

  EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));

  EXPECT_CALL(*command_buffer_, SetParseError(_)).Times(0);

  executor_->PutChanged();
}

TEST_F(CommandExecutorTest, GetSetBuffer) {
  CommandBuffer::State state;

  // Set the get offset to something not 0.
  EXPECT_CALL(*command_buffer_, SetGetOffset(2));
  executor_->SetGetOffset(2);
  EXPECT_EQ(2, executor_->GetGetOffset());

  // Set the buffer.
  EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId))
      .WillOnce(Return(shared_memory_buffer_));
  EXPECT_CALL(*command_buffer_, SetGetOffset(0));
  EXPECT_TRUE(executor_->SetGetBuffer(kTransferBufferId));

  // Check the get offset was reset.
  EXPECT_EQ(0, executor_->GetGetOffset());
}

TEST_F(CommandExecutorTest, ProcessesOneCommand) {
  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
  header[0].command = 7;
  header[0].size = 2;
  buffer_[1] = 123;

  CommandBuffer::State state;

  EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));
  EXPECT_CALL(*command_buffer_, GetPutOffset()).WillRepeatedly(Return(2));
  EXPECT_CALL(*command_buffer_, SetGetOffset(2));

  EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
      .WillOnce(Return(error::kNoError));

  EXPECT_CALL(*command_buffer_, SetParseError(_)).Times(0);

  executor_->PutChanged();
}

TEST_F(CommandExecutorTest, ProcessesTwoCommands) {
  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
  header[0].command = 7;
  header[0].size = 2;
  buffer_[1] = 123;
  header[2].command = 8;
  header[2].size = 1;

  CommandBuffer::State state;

  EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));
  EXPECT_CALL(*command_buffer_, GetPutOffset()).WillRepeatedly(Return(3));

  EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0]))
      .WillOnce(Return(error::kNoError));

  EXPECT_CALL(*decoder_, DoCommand(8, 0, &buffer_[2]))
      .WillOnce(Return(error::kNoError));
  EXPECT_CALL(*command_buffer_, SetGetOffset(3));

  executor_->PutChanged();
}

TEST_F(CommandExecutorTest, SetsErrorCodeOnCommandBuffer) {
  CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]);
  header[0].command = 7;
  header[0].size = 1;

  CommandBuffer::State state;

  EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));
  EXPECT_CALL(*command_buffer_, GetPutOffset()).WillRepeatedly(Return(1));

  EXPECT_CALL(*decoder_, DoCommand(7, 0, &buffer_[0]))
      .WillOnce(Return(error::kUnknownCommand));
  EXPECT_CALL(*command_buffer_, SetGetOffset(1));

  EXPECT_CALL(*command_buffer_, SetContextLostReason(_));
  EXPECT_CALL(*decoder_, GetContextLostReason())
      .WillOnce(Return(error::kUnknown));
  EXPECT_CALL(*command_buffer_, SetParseError(error::kUnknownCommand));

  executor_->PutChanged();
}

TEST_F(CommandExecutorTest, ProcessCommandsDoesNothingAfterError) {
  CommandBuffer::State state;
  state.error = error::kGenericError;

  EXPECT_CALL(*command_buffer_, GetLastState()).WillRepeatedly(Return(state));

  executor_->PutChanged();
}

TEST_F(CommandExecutorTest, CanGetAddressOfSharedMemory) {
  EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
      .WillOnce(Return(shared_memory_buffer_));

  EXPECT_EQ(&buffer_[0], executor_->GetSharedMemoryBuffer(7)->memory());
}

ACTION_P2(SetPointee, address, value) {
  *address = value;
}

TEST_F(CommandExecutorTest, CanGetSizeOfSharedMemory) {
  EXPECT_CALL(*command_buffer_.get(), GetTransferBuffer(7))
      .WillOnce(Return(shared_memory_buffer_));

  EXPECT_EQ(kRingBufferSize, executor_->GetSharedMemoryBuffer(7)->size());
}

TEST_F(CommandExecutorTest, SetTokenForwardsToCommandBuffer) {
  EXPECT_CALL(*command_buffer_, SetToken(7));
  executor_->set_token(7);
}

}  // namespace gpu