1// Copyright (c) 2012 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// This file contains definitions for mock objects, used for testing.
6
7// TODO(apatrick): This file "manually" defines some mock objects. Using gMock
8// would be definitely preferable, unfortunately it doesn't work on Windows yet.
9
10#ifndef GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
11#define GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
12
13#include <string>
14#include <vector>
15
16#include "base/logging.h"
17#include "gpu/command_buffer/service/cmd_parser.h"
18#include "gpu/command_buffer/service/cmd_buffer_engine.h"
19#include "gpu/command_buffer/service/memory_tracking.h"
20#include "gpu/command_buffer/service/program_cache.h"
21#include "gpu/command_buffer/service/shader_translator.h"
22#include "testing/gmock/include/gmock/gmock.h"
23
24namespace gpu {
25
26// Mocks an AsyncAPIInterface, using GMock.
27class AsyncAPIMock : public AsyncAPIInterface {
28 public:
29  explicit AsyncAPIMock(bool default_do_commands);
30  virtual ~AsyncAPIMock();
31
32  error::Error FakeDoCommands(unsigned int num_commands,
33                              const void* buffer,
34                              int num_entries,
35                              int* entries_processed);
36
37  // Predicate that matches args passed to DoCommand, by looking at the values.
38  class IsArgs {
39   public:
40    IsArgs(unsigned int arg_count, const void* args)
41        : arg_count_(arg_count),
42          args_(static_cast<CommandBufferEntry*>(const_cast<void*>(args))) {
43    }
44
45    bool operator() (const void* _args) const {
46      const CommandBufferEntry* args =
47          static_cast<const CommandBufferEntry*>(_args) + 1;
48      for (unsigned int i = 0; i < arg_count_; ++i) {
49        if (args[i].value_uint32 != args_[i].value_uint32) return false;
50      }
51      return true;
52    }
53
54   private:
55    unsigned int arg_count_;
56    CommandBufferEntry *args_;
57  };
58
59  MOCK_METHOD3(DoCommand, error::Error(
60      unsigned int command,
61      unsigned int arg_count,
62      const void* cmd_data));
63
64  MOCK_METHOD4(DoCommands,
65               error::Error(unsigned int num_commands,
66                            const void* buffer,
67                            int num_entries,
68                            int* entries_processed));
69
70  const char* GetCommandName(unsigned int command_id) const {
71    return "";
72  };
73
74  // Sets the engine, to forward SetToken commands to it.
75  void set_engine(CommandBufferEngine *engine) { engine_ = engine; }
76
77  // Forwards the SetToken commands to the engine.
78  void SetToken(unsigned int command,
79                unsigned int arg_count,
80                const void* _args);
81
82 private:
83  CommandBufferEngine *engine_;
84};
85
86namespace gles2 {
87
88class MockShaderTranslator : public ShaderTranslatorInterface {
89 public:
90  MockShaderTranslator();
91  virtual ~MockShaderTranslator();
92
93  MOCK_METHOD5(Init, bool(
94      sh::GLenum shader_type,
95      ShShaderSpec shader_spec,
96      const ShBuiltInResources* resources,
97      GlslImplementationType glsl_implementation_type,
98      ShCompileOptions driver_bug_workarounds));
99  MOCK_CONST_METHOD7(Translate, bool(
100      const std::string& shader_source,
101      std::string* info_log,
102      std::string* translated_source,
103      VariableMap* attrib_map,
104      VariableMap* uniform_map,
105      VariableMap* varying_map,
106      NameMap* name_map));
107  MOCK_CONST_METHOD0(
108      GetStringForOptionsThatWouldAffectCompilation, std::string());
109};
110
111class MockProgramCache : public ProgramCache {
112 public:
113  MockProgramCache();
114  virtual ~MockProgramCache();
115
116  MOCK_METHOD7(LoadLinkedProgram, ProgramLoadResult(
117      GLuint program,
118      Shader* shader_a,
119      const ShaderTranslatorInterface* translator_a,
120      Shader* shader_b,
121      const ShaderTranslatorInterface* translator_b,
122      const LocationMap* bind_attrib_location_map,
123      const ShaderCacheCallback& callback));
124
125  MOCK_METHOD7(SaveLinkedProgram, void(
126      GLuint program,
127      const Shader* shader_a,
128      const ShaderTranslatorInterface* translator_a,
129      const Shader* shader_b,
130      const ShaderTranslatorInterface* translator_b,
131      const LocationMap* bind_attrib_location_map,
132      const ShaderCacheCallback& callback));
133  MOCK_METHOD1(LoadProgram, void(const std::string&));
134
135 private:
136  MOCK_METHOD0(ClearBackend, void());
137};
138
139class MockMemoryTracker : public MemoryTracker {
140 public:
141  MockMemoryTracker();
142
143  MOCK_METHOD3(TrackMemoryAllocatedChange, void(
144      size_t old_size, size_t new_size, Pool pool));
145  MOCK_METHOD1(EnsureGPUMemoryAvailable, bool(size_t size_needed));
146
147 private:
148  friend class ::testing::StrictMock<MockMemoryTracker>;
149  friend class base::RefCounted< ::testing::StrictMock<MockMemoryTracker> >;
150  virtual ~MockMemoryTracker();
151};
152
153}  // namespace gles2
154}  // namespace gpu
155
156#endif  // GPU_COMMAND_BUFFER_SERVICE_MOCKS_H_
157