Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(101)

Side by Side Diff: cc/resources/resource_provider_unittest.cc

Issue 1479673003: Verify resource provider sync tokens before sending to parent. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Fixed unit test so it doesn't expect dummy fence sync Created 4 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/resources/resource_provider.cc ('k') | cc/test/test_gles2_interface.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2012 The Chromium Authors. All rights reserved. 1 // Copyright 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "cc/resources/resource_provider.h" 5 #include "cc/resources/resource_provider.h"
6 6
7 #include <stddef.h> 7 #include <stddef.h>
8 #include <stdint.h> 8 #include <stdint.h>
9 9
10 #include <algorithm> 10 #include <algorithm>
(...skipping 21 matching lines...) Expand all
32 #include "testing/gmock/include/gmock/gmock.h" 32 #include "testing/gmock/include/gmock/gmock.h"
33 #include "testing/gtest/include/gtest/gtest.h" 33 #include "testing/gtest/include/gtest/gtest.h"
34 #include "third_party/khronos/GLES2/gl2.h" 34 #include "third_party/khronos/GLES2/gl2.h"
35 #include "third_party/khronos/GLES2/gl2ext.h" 35 #include "third_party/khronos/GLES2/gl2ext.h"
36 #include "ui/gfx/geometry/rect.h" 36 #include "ui/gfx/geometry/rect.h"
37 #include "ui/gfx/gpu_memory_buffer.h" 37 #include "ui/gfx/gpu_memory_buffer.h"
38 38
39 using testing::Mock; 39 using testing::Mock;
40 using testing::NiceMock; 40 using testing::NiceMock;
41 using testing::Return; 41 using testing::Return;
42 using testing::SetArgPointee;
43 using testing::StrictMock; 42 using testing::StrictMock;
44 using testing::_; 43 using testing::_;
45 44
46 namespace cc { 45 namespace cc {
47 namespace { 46 namespace {
48 47
49 MATCHER_P(MatchesSyncToken, sync_token, "") { 48 MATCHER_P(MatchesSyncToken, sync_token, "") {
50 gpu::SyncToken other; 49 gpu::SyncToken other;
51 memcpy(&other, arg, sizeof(other)); 50 memcpy(&other, arg, sizeof(other));
52 return other == sync_token; 51 return other == sync_token;
(...skipping 44 matching lines...) Expand 10 before | Expand all | Expand 10 after
97 CHECK(pixels); 96 CHECK(pixels);
98 std::fill_n(pixels, size.GetArea(), value); 97 std::fill_n(pixels, size.GetArea(), value);
99 return shared_bitmap; 98 return shared_bitmap;
100 } 99 }
101 100
102 class TextureStateTrackingContext : public TestWebGraphicsContext3D { 101 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
103 public: 102 public:
104 MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture)); 103 MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
105 MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param)); 104 MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
106 MOCK_METHOD1(waitSyncToken, void(const GLbyte* sync_token)); 105 MOCK_METHOD1(waitSyncToken, void(const GLbyte* sync_token));
107 MOCK_METHOD0(insertSyncPoint, GLuint(void));
108 MOCK_METHOD3(produceTextureDirectCHROMIUM, 106 MOCK_METHOD3(produceTextureDirectCHROMIUM,
109 void(GLuint texture, GLenum target, const GLbyte* mailbox)); 107 void(GLuint texture, GLenum target, const GLbyte* mailbox));
110 MOCK_METHOD2(createAndConsumeTextureCHROMIUM, 108 MOCK_METHOD2(createAndConsumeTextureCHROMIUM,
111 unsigned(GLenum target, const GLbyte* mailbox)); 109 unsigned(GLenum target, const GLbyte* mailbox));
112 110
113 // Force all textures to be consecutive numbers starting at "1", 111 // Force all textures to be consecutive numbers starting at "1",
114 // so we easily can test for them. 112 // so we easily can test for them.
115 GLuint NextTextureId() override { 113 GLuint NextTextureId() override {
116 base::AutoLock lock(namespace_->lock); 114 base::AutoLock lock(namespace_->lock);
117 return namespace_->next_texture_id++; 115 return namespace_->next_texture_id++;
118 } 116 }
117
119 void RetireTextureId(GLuint) override {} 118 void RetireTextureId(GLuint) override {}
119
120 GLuint64 insertFenceSync() override { return next_fence_sync_++; }
121
122 void genSyncToken(GLuint64 fence_sync, GLbyte* sync_token) override {
123 gpu::SyncToken sync_token_data(gpu::CommandBufferNamespace::GPU_IO, 0,
124 0x123, fence_sync);
125 sync_token_data.SetVerifyFlush();
126 memcpy(sync_token, &sync_token_data, sizeof(sync_token_data));
127 }
128
129 GLuint64 GetNextFenceSync() const { return next_fence_sync_; }
130
131 GLuint64 next_fence_sync_ = 1;
120 }; 132 };
121 133
122 // Shared data between multiple ResourceProviderContext. This contains mailbox 134 // Shared data between multiple ResourceProviderContext. This contains mailbox
123 // contents as well as information about sync points. 135 // contents as well as information about sync points.
124 class ContextSharedData { 136 class ContextSharedData {
125 public: 137 public:
126 static scoped_ptr<ContextSharedData> Create() { 138 static scoped_ptr<ContextSharedData> Create() {
127 return make_scoped_ptr(new ContextSharedData()); 139 return make_scoped_ptr(new ContextSharedData());
128 } 140 }
129 141
130 uint32_t InsertSyncPoint() { return next_sync_point_++; } 142 uint32_t InsertFenceSync() { return next_fence_sync_++; }
131 143
132 void GenMailbox(GLbyte* mailbox) { 144 void GenMailbox(GLbyte* mailbox) {
133 memset(mailbox, 0, GL_MAILBOX_SIZE_CHROMIUM); 145 memset(mailbox, 0, GL_MAILBOX_SIZE_CHROMIUM);
134 memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_)); 146 memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
135 ++next_mailbox_; 147 ++next_mailbox_;
136 } 148 }
137 149
138 void ProduceTexture(const GLbyte* mailbox_name, 150 void ProduceTexture(const GLbyte* mailbox_name,
139 const gpu::SyncToken& sync_token, 151 const gpu::SyncToken& sync_token,
140 scoped_refptr<TestTexture> texture) { 152 scoped_refptr<TestTexture> texture) {
(...skipping 17 matching lines...) Expand all
158 // point for when the mailbox was set, pretend we never saw that 170 // point for when the mailbox was set, pretend we never saw that
159 // ProduceTexture. 171 // ProduceTexture.
160 if (sync_point_for_mailbox_[mailbox] > sync_token.release_count()) { 172 if (sync_point_for_mailbox_[mailbox] > sync_token.release_count()) {
161 NOTREACHED(); 173 NOTREACHED();
162 return scoped_refptr<TestTexture>(); 174 return scoped_refptr<TestTexture>();
163 } 175 }
164 return textures_[mailbox]; 176 return textures_[mailbox];
165 } 177 }
166 178
167 private: 179 private:
168 ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {} 180 ContextSharedData() : next_fence_sync_(1), next_mailbox_(1) {}
169 181
170 uint32_t next_sync_point_; 182 uint64_t next_fence_sync_;
171 unsigned next_mailbox_; 183 unsigned next_mailbox_;
172 typedef base::hash_map<unsigned, scoped_refptr<TestTexture>> TextureMap; 184 typedef base::hash_map<unsigned, scoped_refptr<TestTexture>> TextureMap;
173 TextureMap textures_; 185 TextureMap textures_;
174 base::hash_map<unsigned, uint32_t> sync_point_for_mailbox_; 186 base::hash_map<unsigned, uint32_t> sync_point_for_mailbox_;
175 }; 187 };
176 188
177 class ResourceProviderContext : public TestWebGraphicsContext3D { 189 class ResourceProviderContext : public TestWebGraphicsContext3D {
178 public: 190 public:
179 static scoped_ptr<ResourceProviderContext> Create( 191 static scoped_ptr<ResourceProviderContext> Create(
180 ContextSharedData* shared_data) { 192 ContextSharedData* shared_data) {
181 return make_scoped_ptr(new ResourceProviderContext(shared_data)); 193 return make_scoped_ptr(new ResourceProviderContext(shared_data));
182 } 194 }
183 195
184 GLuint insertSyncPoint() override { 196 GLuint insertSyncPoint() override {
185 uint32_t sync_point = shared_data_->InsertSyncPoint(); 197 const uint32_t sync_point =
198 static_cast<uint32_t>(shared_data_->InsertFenceSync());
199 gpu::SyncToken sync_token_data(sync_point);
200
186 // Commit the produceTextureCHROMIUM calls at this point, so that 201 // Commit the produceTextureCHROMIUM calls at this point, so that
187 // they're associated with the sync point. 202 // they're associated with the sync point.
188 for (const scoped_ptr<PendingProduceTexture>& pending_texture : 203 for (const scoped_ptr<PendingProduceTexture>& pending_texture :
189 pending_produce_textures_) { 204 pending_produce_textures_) {
190 shared_data_->ProduceTexture(pending_texture->mailbox, 205 shared_data_->ProduceTexture(pending_texture->mailbox, sync_token_data,
191 gpu::SyncToken(sync_point),
192 pending_texture->texture); 206 pending_texture->texture);
193 } 207 }
194 pending_produce_textures_.clear(); 208 pending_produce_textures_.clear();
195 return sync_point; 209 return sync_point;
196 } 210 }
197 211
212 GLuint64 insertFenceSync() override {
213 return shared_data_->InsertFenceSync();
214 }
215
216 void genSyncToken(GLuint64 fence_sync, GLbyte* sync_token) override {
217 gpu::SyncToken sync_token_data(gpu::CommandBufferNamespace::GPU_IO, 0,
218 0x123, fence_sync);
219 sync_token_data.SetVerifyFlush();
220 // Commit the produceTextureCHROMIUM calls at this point, so that
221 // they're associated with the sync point.
222 for (const scoped_ptr<PendingProduceTexture>& pending_texture :
223 pending_produce_textures_) {
224 shared_data_->ProduceTexture(pending_texture->mailbox, sync_token_data,
225 pending_texture->texture);
226 }
227 pending_produce_textures_.clear();
228 memcpy(sync_token, &sync_token_data, sizeof(sync_token_data));
229 }
230
198 void waitSyncToken(const GLbyte* sync_token) override { 231 void waitSyncToken(const GLbyte* sync_token) override {
199 gpu::SyncToken sync_token_data; 232 gpu::SyncToken sync_token_data;
200 if (sync_token) 233 if (sync_token)
201 memcpy(&sync_token_data, sync_token, sizeof(sync_token_data)); 234 memcpy(&sync_token_data, sync_token, sizeof(sync_token_data));
202 235
203 if (sync_token_data.release_count() > 236 if (sync_token_data.release_count() >
204 last_waited_sync_token_.release_count()) { 237 last_waited_sync_token_.release_count()) {
205 last_waited_sync_token_ = sync_token_data; 238 last_waited_sync_token_ = sync_token_data;
206 } 239 }
207 } 240 }
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after
273 } 306 }
274 307
275 void genMailboxCHROMIUM(GLbyte* mailbox) override { 308 void genMailboxCHROMIUM(GLbyte* mailbox) override {
276 return shared_data_->GenMailbox(mailbox); 309 return shared_data_->GenMailbox(mailbox);
277 } 310 }
278 311
279 void produceTextureDirectCHROMIUM(GLuint texture, 312 void produceTextureDirectCHROMIUM(GLuint texture,
280 GLenum target, 313 GLenum target,
281 const GLbyte* mailbox) override { 314 const GLbyte* mailbox) override {
282 // Delay moving the texture into the mailbox until the next 315 // Delay moving the texture into the mailbox until the next
283 // InsertSyncPoint, so that it is not visible to other contexts that 316 // sync token, so that it is not visible to other contexts that
284 // haven't waited on that sync point. 317 // haven't waited on that sync point.
285 scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture); 318 scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
286 memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox)); 319 memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
287 base::AutoLock lock_for_texture_access(namespace_->lock); 320 base::AutoLock lock_for_texture_access(namespace_->lock);
288 pending->texture = UnboundTexture(texture); 321 pending->texture = UnboundTexture(texture);
289 pending_produce_textures_.push_back(std::move(pending)); 322 pending_produce_textures_.push_back(std::move(pending));
290 } 323 }
291 324
292 GLuint createAndConsumeTextureCHROMIUM(GLenum target, 325 GLuint createAndConsumeTextureCHROMIUM(GLenum target,
293 const GLbyte* mailbox) override { 326 const GLbyte* mailbox) override {
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after
470 ResourceId CreateChildMailbox(gpu::SyncToken* release_sync_token, 503 ResourceId CreateChildMailbox(gpu::SyncToken* release_sync_token,
471 bool* lost_resource, 504 bool* lost_resource,
472 bool* release_called, 505 bool* release_called,
473 gpu::SyncToken* sync_token) { 506 gpu::SyncToken* sync_token) {
474 if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) { 507 if (GetParam() == ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) {
475 unsigned texture = child_context_->createTexture(); 508 unsigned texture = child_context_->createTexture();
476 gpu::Mailbox gpu_mailbox; 509 gpu::Mailbox gpu_mailbox;
477 child_context_->genMailboxCHROMIUM(gpu_mailbox.name); 510 child_context_->genMailboxCHROMIUM(gpu_mailbox.name);
478 child_context_->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, 511 child_context_->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D,
479 gpu_mailbox.name); 512 gpu_mailbox.name);
480 *sync_token = gpu::SyncToken(child_context_->insertSyncPoint()); 513 child_context_->genSyncToken(child_context_->insertFenceSync(),
514 sync_token->GetData());
481 EXPECT_TRUE(sync_token->HasData()); 515 EXPECT_TRUE(sync_token->HasData());
482 516
483 scoped_ptr<SharedBitmap> shared_bitmap; 517 scoped_ptr<SharedBitmap> shared_bitmap;
484 scoped_ptr<SingleReleaseCallbackImpl> callback = 518 scoped_ptr<SingleReleaseCallbackImpl> callback =
485 SingleReleaseCallbackImpl::Create(base::Bind( 519 SingleReleaseCallbackImpl::Create(base::Bind(
486 ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap), 520 ReleaseSharedBitmapCallback, base::Passed(&shared_bitmap),
487 release_called, release_sync_token, lost_resource)); 521 release_called, release_sync_token, lost_resource));
488 return child_resource_provider_->CreateResourceFromTextureMailbox( 522 return child_resource_provider_->CreateResourceFromTextureMailbox(
489 TextureMailbox(gpu_mailbox, *sync_token, GL_TEXTURE_2D), 523 TextureMailbox(gpu_mailbox, *sync_token, GL_TEXTURE_2D),
490 std::move(callback)); 524 std::move(callback));
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after
626 child_resource_provider_.get(), id3); 660 child_resource_provider_.get(), id3);
627 EXPECT_TRUE(lock.GetGpuMemoryBuffer()); 661 EXPECT_TRUE(lock.GetGpuMemoryBuffer());
628 } 662 }
629 663
630 GLuint external_texture_id = child_context_->createExternalTexture(); 664 GLuint external_texture_id = child_context_->createExternalTexture();
631 665
632 gpu::Mailbox external_mailbox; 666 gpu::Mailbox external_mailbox;
633 child_context_->genMailboxCHROMIUM(external_mailbox.name); 667 child_context_->genMailboxCHROMIUM(external_mailbox.name);
634 child_context_->produceTextureDirectCHROMIUM( 668 child_context_->produceTextureDirectCHROMIUM(
635 external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name); 669 external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
636 const gpu::SyncToken external_sync_token(child_context_->insertSyncPoint()); 670 gpu::SyncToken external_sync_token;
671 child_context_->genSyncToken(child_context_->insertFenceSync(),
672 external_sync_token.GetData());
673 EXPECT_TRUE(external_sync_token.HasData());
637 ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox( 674 ResourceId id4 = child_resource_provider_->CreateResourceFromTextureMailbox(
638 TextureMailbox(external_mailbox, external_sync_token, 675 TextureMailbox(external_mailbox, external_sync_token,
639 GL_TEXTURE_EXTERNAL_OES), 676 GL_TEXTURE_EXTERNAL_OES),
640 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); 677 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
641 678
642 ReturnedResourceArray returned_to_child; 679 ReturnedResourceArray returned_to_child;
643 int child_id = 680 int child_id =
644 resource_provider_->CreateChild(GetReturnCallback(&returned_to_child)); 681 resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
645 { 682 {
646 // Transfer some resources to the parent. 683 // Transfer some resources to the parent.
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after
882 EXPECT_TRUE(lock.GetGpuMemoryBuffer()); 919 EXPECT_TRUE(lock.GetGpuMemoryBuffer());
883 } 920 }
884 921
885 GLuint external_texture_id = child_context_->createExternalTexture(); 922 GLuint external_texture_id = child_context_->createExternalTexture();
886 923
887 // A sync point is specified directly and should be used. 924 // A sync point is specified directly and should be used.
888 gpu::Mailbox external_mailbox; 925 gpu::Mailbox external_mailbox;
889 child_context_->genMailboxCHROMIUM(external_mailbox.name); 926 child_context_->genMailboxCHROMIUM(external_mailbox.name);
890 child_context_->produceTextureDirectCHROMIUM( 927 child_context_->produceTextureDirectCHROMIUM(
891 external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name); 928 external_texture_id, GL_TEXTURE_EXTERNAL_OES, external_mailbox.name);
892 const gpu::SyncToken external_sync_token(child_context_->insertSyncPoint()); 929 gpu::SyncToken external_sync_token;
930 child_context_->genSyncToken(child_context_->insertFenceSync(),
931 external_sync_token.GetData());
932 EXPECT_TRUE(external_sync_token.HasData());
893 ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox( 933 ResourceId id3 = child_resource_provider_->CreateResourceFromTextureMailbox(
894 TextureMailbox(external_mailbox, external_sync_token, 934 TextureMailbox(external_mailbox, external_sync_token,
895 GL_TEXTURE_EXTERNAL_OES), 935 GL_TEXTURE_EXTERNAL_OES),
896 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback))); 936 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
897 937
898 ReturnedResourceArray returned_to_child; 938 ReturnedResourceArray returned_to_child;
899 int child_id = 939 int child_id =
900 resource_provider_->CreateChild(GetReturnCallback(&returned_to_child)); 940 resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
901 resource_provider_->SetChildNeedsSyncTokens(child_id, false); 941 resource_provider_->SetChildNeedsSyncTokens(child_id, false);
902 { 942 {
(...skipping 1051 matching lines...) Expand 10 before | Expand all | Expand 10 after
1954 int child_id = parent_resource_provider->CreateChild( 1994 int child_id = parent_resource_provider->CreateChild(
1955 GetReturnCallback(&returned_to_child)); 1995 GetReturnCallback(&returned_to_child));
1956 { 1996 {
1957 // Transfer some resource to the parent. 1997 // Transfer some resource to the parent.
1958 ResourceProvider::ResourceIdArray resource_ids_to_transfer; 1998 ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1959 resource_ids_to_transfer.push_back(id); 1999 resource_ids_to_transfer.push_back(id);
1960 TransferableResourceArray list; 2000 TransferableResourceArray list;
1961 2001
1962 EXPECT_CALL(*child_context, 2002 EXPECT_CALL(*child_context,
1963 produceTextureDirectCHROMIUM(_, GL_TEXTURE_2D, _)); 2003 produceTextureDirectCHROMIUM(_, GL_TEXTURE_2D, _));
1964 EXPECT_CALL(*child_context, insertSyncPoint());
1965 child_resource_provider->PrepareSendToParent(resource_ids_to_transfer, 2004 child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
1966 &list); 2005 &list);
1967 Mock::VerifyAndClearExpectations(child_context); 2006 Mock::VerifyAndClearExpectations(child_context);
1968 2007
1969 ASSERT_EQ(1u, list.size()); 2008 ASSERT_EQ(1u, list.size());
1970 EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter); 2009 EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter);
1971 2010
1972 EXPECT_CALL(*parent_context, 2011 EXPECT_CALL(*parent_context,
1973 createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _)) 2012 createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, _))
1974 .WillOnce(Return(parent_texture_id)); 2013 .WillOnce(Return(parent_texture_id));
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after
2012 EXPECT_CALL( 2051 EXPECT_CALL(
2013 *parent_context, 2052 *parent_context,
2014 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, child_filter)); 2053 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, child_filter));
2015 2054
2016 { 2055 {
2017 EXPECT_EQ(0u, returned_to_child.size()); 2056 EXPECT_EQ(0u, returned_to_child.size());
2018 2057
2019 // Transfer resources back from the parent to the child. Set no resources 2058 // Transfer resources back from the parent to the child. Set no resources
2020 // as being in use. 2059 // as being in use.
2021 ResourceProvider::ResourceIdSet no_resources; 2060 ResourceProvider::ResourceIdSet no_resources;
2022 EXPECT_CALL(*parent_context, insertSyncPoint());
2023 parent_resource_provider->DeclareUsedResourcesFromChild(child_id, 2061 parent_resource_provider->DeclareUsedResourcesFromChild(child_id,
2024 no_resources); 2062 no_resources);
2025 Mock::VerifyAndClearExpectations(parent_context); 2063 Mock::VerifyAndClearExpectations(parent_context);
2026 2064
2027 ASSERT_EQ(1u, returned_to_child.size()); 2065 ASSERT_EQ(1u, returned_to_child.size());
2028 child_resource_provider->ReceiveReturnsFromParent(returned_to_child); 2066 child_resource_provider->ReceiveReturnsFromParent(returned_to_child);
2029 } 2067 }
2030 2068
2031 // The child remembers the texture filter is set to |child_filter|. 2069 // The child remembers the texture filter is set to |child_filter|.
2032 EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id)); 2070 EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
(...skipping 19 matching lines...) Expand all
2052 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) 2090 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
2053 return; 2091 return;
2054 unsigned texture = context()->createTexture(); 2092 unsigned texture = context()->createTexture();
2055 context()->bindTexture(GL_TEXTURE_2D, texture); 2093 context()->bindTexture(GL_TEXTURE_2D, texture);
2056 uint8_t data[4] = { 1, 2, 3, 4 }; 2094 uint8_t data[4] = { 1, 2, 3, 4 };
2057 context()->texImage2D( 2095 context()->texImage2D(
2058 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data); 2096 GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
2059 gpu::Mailbox mailbox; 2097 gpu::Mailbox mailbox;
2060 context()->genMailboxCHROMIUM(mailbox.name); 2098 context()->genMailboxCHROMIUM(mailbox.name);
2061 context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name); 2099 context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
2062 gpu::SyncToken sync_token(context()->insertSyncPoint()); 2100 gpu::SyncToken sync_token;
2101 context()->genSyncToken(context()->insertFenceSync(), sync_token.GetData());
2102 EXPECT_TRUE(sync_token.HasData());
2063 2103
2064 // All the logic below assumes that the sync token releases are all positive. 2104 // All the logic below assumes that the sync token releases are all positive.
2065 EXPECT_LT(0u, sync_token.release_count()); 2105 EXPECT_LT(0u, sync_token.release_count());
2066 2106
2067 gpu::SyncToken release_sync_token; 2107 gpu::SyncToken release_sync_token;
2068 bool lost_resource = false; 2108 bool lost_resource = false;
2069 BlockingTaskRunner* main_thread_task_runner = NULL; 2109 BlockingTaskRunner* main_thread_task_runner = NULL;
2070 ReleaseCallbackImpl callback = 2110 ReleaseCallbackImpl callback =
2071 base::Bind(ReleaseCallback, &release_sync_token, &lost_resource, 2111 base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
2072 &main_thread_task_runner); 2112 &main_thread_task_runner);
(...skipping 21 matching lines...) Expand all
2094 unsigned other_texture = 2134 unsigned other_texture =
2095 context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name); 2135 context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
2096 uint8_t test_data[4] = { 0 }; 2136 uint8_t test_data[4] = { 0 };
2097 context()->GetPixels( 2137 context()->GetPixels(
2098 gfx::Size(1, 1), RGBA_8888, test_data); 2138 gfx::Size(1, 1), RGBA_8888, test_data);
2099 EXPECT_EQ(0, memcmp(data, test_data, sizeof(data))); 2139 EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
2100 2140
2101 context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D, 2141 context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
2102 mailbox.name); 2142 mailbox.name);
2103 context()->deleteTexture(other_texture); 2143 context()->deleteTexture(other_texture);
2104 list[0].mailbox_holder.sync_token = 2144 context()->genSyncToken(context()->insertFenceSync(),
2105 gpu::SyncToken(context()->insertSyncPoint()); 2145 list[0].mailbox_holder.sync_token.GetData());
2146 EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
2106 2147
2107 // Receive the resource, then delete it, expect the sync points to be 2148 // Receive the resource, then delete it, expect the sync points to be
2108 // consistent. 2149 // consistent.
2109 ReturnedResourceArray returned; 2150 ReturnedResourceArray returned;
2110 TransferableResource::ReturnResources(list, &returned); 2151 TransferableResource::ReturnResources(list, &returned);
2111 resource_provider_->ReceiveReturnsFromParent(returned); 2152 resource_provider_->ReceiveReturnsFromParent(returned);
2112 EXPECT_EQ(1u, context()->NumTextures()); 2153 EXPECT_EQ(1u, context()->NumTextures());
2113 EXPECT_FALSE(release_sync_token.HasData()); 2154 EXPECT_FALSE(release_sync_token.HasData());
2114 2155
2115 resource_provider_->DeleteResource(resource); 2156 resource_provider_->DeleteResource(resource);
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
2148 unsigned other_texture = 2189 unsigned other_texture =
2149 context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name); 2190 context()->createAndConsumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
2150 uint8_t test_data[4] = { 0 }; 2191 uint8_t test_data[4] = { 0 };
2151 context()->GetPixels( 2192 context()->GetPixels(
2152 gfx::Size(1, 1), RGBA_8888, test_data); 2193 gfx::Size(1, 1), RGBA_8888, test_data);
2153 EXPECT_EQ(0, memcmp(data, test_data, sizeof(data))); 2194 EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
2154 2195
2155 context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D, 2196 context()->produceTextureDirectCHROMIUM(other_texture, GL_TEXTURE_2D,
2156 mailbox.name); 2197 mailbox.name);
2157 context()->deleteTexture(other_texture); 2198 context()->deleteTexture(other_texture);
2158 list[0].mailbox_holder.sync_token = 2199 context()->genSyncToken(context()->insertFenceSync(),
2159 gpu::SyncToken(context()->insertSyncPoint()); 2200 list[0].mailbox_holder.sync_token.GetData());
2160 EXPECT_LT(0u, list[0].mailbox_holder.sync_token.release_count()); 2201 EXPECT_TRUE(list[0].mailbox_holder.sync_token.HasData());
2161 2202
2162 // Delete the resource, which shouldn't do anything. 2203 // Delete the resource, which shouldn't do anything.
2163 resource_provider_->DeleteResource(resource); 2204 resource_provider_->DeleteResource(resource);
2164 EXPECT_EQ(1u, context()->NumTextures()); 2205 EXPECT_EQ(1u, context()->NumTextures());
2165 EXPECT_FALSE(release_sync_token.HasData()); 2206 EXPECT_FALSE(release_sync_token.HasData());
2166 2207
2167 // Then receive the resource which should release the mailbox, expect the 2208 // Then receive the resource which should release the mailbox, expect the
2168 // sync points to be consistent. 2209 // sync points to be consistent.
2169 ReturnedResourceArray returned; 2210 ReturnedResourceArray returned;
2170 TransferableResource::ReturnResources(list, &returned); 2211 TransferableResource::ReturnResources(list, &returned);
(...skipping 312 matching lines...) Expand 10 before | Expand all | Expand 10 after
2483 2524
2484 TEST_P(ResourceProviderTest, LostContext) { 2525 TEST_P(ResourceProviderTest, LostContext) {
2485 // TextureMailbox callbacks only exist for GL textures for now. 2526 // TextureMailbox callbacks only exist for GL textures for now.
2486 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) 2527 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
2487 return; 2528 return;
2488 unsigned texture = context()->createTexture(); 2529 unsigned texture = context()->createTexture();
2489 context()->bindTexture(GL_TEXTURE_2D, texture); 2530 context()->bindTexture(GL_TEXTURE_2D, texture);
2490 gpu::Mailbox mailbox; 2531 gpu::Mailbox mailbox;
2491 context()->genMailboxCHROMIUM(mailbox.name); 2532 context()->genMailboxCHROMIUM(mailbox.name);
2492 context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name); 2533 context()->produceTextureDirectCHROMIUM(texture, GL_TEXTURE_2D, mailbox.name);
2493 gpu::SyncToken sync_token(context()->insertSyncPoint()); 2534 gpu::SyncToken sync_token;
2535 context()->genSyncToken(context()->insertFenceSync(), sync_token.GetData());
2494 2536
2495 EXPECT_TRUE(sync_token.HasData()); 2537 EXPECT_TRUE(sync_token.HasData());
2496 2538
2497 gpu::SyncToken release_sync_token; 2539 gpu::SyncToken release_sync_token;
2498 bool lost_resource = false; 2540 bool lost_resource = false;
2499 BlockingTaskRunner* main_thread_task_runner = NULL; 2541 BlockingTaskRunner* main_thread_task_runner = NULL;
2500 scoped_ptr<SingleReleaseCallbackImpl> callback = 2542 scoped_ptr<SingleReleaseCallbackImpl> callback =
2501 SingleReleaseCallbackImpl::Create( 2543 SingleReleaseCallbackImpl::Create(
2502 base::Bind(ReleaseCallback, &release_sync_token, &lost_resource, 2544 base::Bind(ReleaseCallback, &release_sync_token, &lost_resource,
2503 &main_thread_task_runner)); 2545 &main_thread_task_runner));
(...skipping 299 matching lines...) Expand 10 before | Expand all | Expand 10 after
2803 scoped_ptr<OutputSurface> output_surface( 2845 scoped_ptr<OutputSurface> output_surface(
2804 FakeOutputSurface::Create3d(std::move(context_owned))); 2846 FakeOutputSurface::Create3d(std::move(context_owned)));
2805 CHECK(output_surface->BindToClient(&output_surface_client)); 2847 CHECK(output_surface->BindToClient(&output_surface_client));
2806 2848
2807 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create( 2849 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
2808 output_surface.get(), shared_bitmap_manager, gpu_memory_buffer_manager, 2850 output_surface.get(), shared_bitmap_manager, gpu_memory_buffer_manager,
2809 main_thread_task_runner, 0, 1, use_gpu_memory_buffer_resources_, 2851 main_thread_task_runner, 0, 1, use_gpu_memory_buffer_resources_,
2810 use_image_texture_targets_)); 2852 use_image_texture_targets_));
2811 2853
2812 unsigned texture_id = 1; 2854 unsigned texture_id = 1;
2813 gpu::SyncToken sync_token(30); 2855 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, 0x12,
2856 0x34);
2814 unsigned target = GL_TEXTURE_2D; 2857 unsigned target = GL_TEXTURE_2D;
2858 const GLuint64 current_fence_sync = context->GetNextFenceSync();
2815 2859
2816 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 2860 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2817 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 2861 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
2818 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2819 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 2862 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2820 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 2863 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
2821 2864
2822 gpu::Mailbox gpu_mailbox; 2865 gpu::Mailbox gpu_mailbox;
2823 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); 2866 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2824 gpu::SyncToken release_sync_token; 2867 gpu::SyncToken release_sync_token;
2825 bool lost_resource = false; 2868 bool lost_resource = false;
2826 BlockingTaskRunner* mailbox_task_runner = NULL; 2869 BlockingTaskRunner* mailbox_task_runner = NULL;
2827 scoped_ptr<SingleReleaseCallbackImpl> callback = 2870 scoped_ptr<SingleReleaseCallbackImpl> callback =
2828 SingleReleaseCallbackImpl::Create( 2871 SingleReleaseCallbackImpl::Create(
2829 base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource, 2872 base::Bind(&ReleaseCallback, &release_sync_token, &lost_resource,
2830 &mailbox_task_runner)); 2873 &mailbox_task_runner));
2831 2874
2832 TextureMailbox mailbox(gpu_mailbox, sync_token, target); 2875 TextureMailbox mailbox(gpu_mailbox, sync_token, target);
2833 mailbox.set_nearest_neighbor(mailbox_nearest_neighbor); 2876 mailbox.set_nearest_neighbor(mailbox_nearest_neighbor);
2834 2877
2835 ResourceId id = resource_provider->CreateResourceFromTextureMailbox( 2878 ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
2836 mailbox, std::move(callback)); 2879 mailbox, std::move(callback));
2837 EXPECT_NE(0u, id); 2880 EXPECT_NE(0u, id);
2881 EXPECT_EQ(current_fence_sync, context->GetNextFenceSync());
2838 2882
2839 Mock::VerifyAndClearExpectations(context); 2883 Mock::VerifyAndClearExpectations(context);
2840 2884
2841 { 2885 {
2842 // Mailbox sync point WaitSyncToken before using the texture. 2886 // Mailbox sync point WaitSyncToken before using the texture.
2843 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))); 2887 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
2844 resource_provider->WaitSyncTokenIfNeeded(id); 2888 resource_provider->WaitSyncTokenIfNeeded(id);
2845 Mock::VerifyAndClearExpectations(context); 2889 Mock::VerifyAndClearExpectations(context);
2846 2890
2847 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _)) 2891 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
2848 .WillOnce(Return(texture_id)); 2892 .WillOnce(Return(texture_id));
2849 EXPECT_CALL(*context, bindTexture(target, texture_id)); 2893 EXPECT_CALL(*context, bindTexture(target, texture_id));
2850 2894
2851 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2852 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 2895 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2853 2896
2854 // The sampler will reset these if |mailbox_nearest_neighbor| does not 2897 // The sampler will reset these if |mailbox_nearest_neighbor| does not
2855 // match |sampler_filter|. 2898 // match |sampler_filter|.
2856 if (mailbox_nearest_neighbor != (sampler_filter == GL_NEAREST)) { 2899 if (mailbox_nearest_neighbor != (sampler_filter == GL_NEAREST)) {
2857 EXPECT_CALL(*context, texParameteri( 2900 EXPECT_CALL(*context, texParameteri(
2858 GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, sampler_filter)); 2901 GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, sampler_filter));
2859 EXPECT_CALL(*context, texParameteri( 2902 EXPECT_CALL(*context, texParameteri(
2860 GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, sampler_filter)); 2903 GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, sampler_filter));
2861 } 2904 }
2862 2905
2863 ResourceProvider::ScopedSamplerGL lock( 2906 ResourceProvider::ScopedSamplerGL lock(
2864 resource_provider.get(), id, sampler_filter); 2907 resource_provider.get(), id, sampler_filter);
2865 Mock::VerifyAndClearExpectations(context); 2908 Mock::VerifyAndClearExpectations(context);
2909 EXPECT_EQ(current_fence_sync, context->GetNextFenceSync());
2866 2910
2867 // When done with it, a sync point should be inserted, but no produce is 2911 // When done with it, a sync point should be inserted, but no produce is
2868 // necessary. 2912 // necessary.
2869 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 2913 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2870 EXPECT_CALL(*context, insertSyncPoint());
2871 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 2914 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2872 2915
2873 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 2916 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
2874 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 2917 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
2875 } 2918 }
2876 2919
2877 resource_provider->DeleteResource(id); 2920 resource_provider->DeleteResource(id);
2878 EXPECT_FALSE(release_sync_token.HasData()); 2921 EXPECT_TRUE(release_sync_token.HasData());
2879 EXPECT_FALSE(lost_resource); 2922 EXPECT_FALSE(lost_resource);
2880 EXPECT_EQ(main_thread_task_runner, mailbox_task_runner); 2923 EXPECT_EQ(main_thread_task_runner, mailbox_task_runner);
2881 } 2924 }
2882 }; 2925 };
2883 2926
2884 TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToLinear) { 2927 TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D_LinearToLinear) {
2885 // Mailboxing is only supported for GL textures. 2928 // Mailboxing is only supported for GL textures.
2886 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) 2929 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
2887 return; 2930 return;
2888 2931
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
2945 FakeOutputSurfaceClient output_surface_client; 2988 FakeOutputSurfaceClient output_surface_client;
2946 scoped_ptr<OutputSurface> output_surface( 2989 scoped_ptr<OutputSurface> output_surface(
2947 FakeOutputSurface::Create3d(std::move(context_owned))); 2990 FakeOutputSurface::Create3d(std::move(context_owned)));
2948 CHECK(output_surface->BindToClient(&output_surface_client)); 2991 CHECK(output_surface->BindToClient(&output_surface_client));
2949 2992
2950 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create( 2993 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
2951 output_surface.get(), shared_bitmap_manager_.get(), 2994 output_surface.get(), shared_bitmap_manager_.get(),
2952 gpu_memory_buffer_manager_.get(), NULL, 0, 1, 2995 gpu_memory_buffer_manager_.get(), NULL, 0, 1,
2953 use_gpu_memory_buffer_resources_, use_image_texture_targets_)); 2996 use_gpu_memory_buffer_resources_, use_image_texture_targets_));
2954 2997
2955 gpu::SyncToken sync_token(30); 2998 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, 0x12, 0x34);
2999 const GLuint64 current_fence_sync = context->GetNextFenceSync();
2956 unsigned target = GL_TEXTURE_EXTERNAL_OES; 3000 unsigned target = GL_TEXTURE_EXTERNAL_OES;
2957 3001
2958 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 3002 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2959 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 3003 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
2960 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2961 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 3004 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2962 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 3005 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
2963 3006
2964 gpu::Mailbox gpu_mailbox; 3007 gpu::Mailbox gpu_mailbox;
2965 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); 3008 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2966 scoped_ptr<SingleReleaseCallbackImpl> callback = 3009 scoped_ptr<SingleReleaseCallbackImpl> callback =
2967 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); 3010 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
2968 3011
2969 TextureMailbox mailbox(gpu_mailbox, sync_token, target); 3012 TextureMailbox mailbox(gpu_mailbox, sync_token, target);
2970 3013
2971 ResourceId id = resource_provider->CreateResourceFromTextureMailbox( 3014 ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
2972 mailbox, std::move(callback)); 3015 mailbox, std::move(callback));
2973 EXPECT_NE(0u, id); 3016 EXPECT_NE(0u, id);
3017 EXPECT_EQ(current_fence_sync, context->GetNextFenceSync());
2974 3018
2975 Mock::VerifyAndClearExpectations(context); 3019 Mock::VerifyAndClearExpectations(context);
2976 3020
2977 { 3021 {
2978 // Mailbox sync point WaitSyncToken before using the texture. 3022 // Mailbox sync point WaitSyncToken before using the texture.
2979 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))); 3023 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
2980 resource_provider->WaitSyncTokenIfNeeded(id); 3024 resource_provider->WaitSyncTokenIfNeeded(id);
2981 Mock::VerifyAndClearExpectations(context); 3025 Mock::VerifyAndClearExpectations(context);
2982 3026
2983 unsigned texture_id = 1; 3027 unsigned texture_id = 1;
2984 3028
2985 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _)) 3029 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(target, _))
2986 .WillOnce(Return(texture_id)); 3030 .WillOnce(Return(texture_id));
2987 3031
2988 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2989 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 3032 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2990 3033
2991 ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id); 3034 ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
2992 Mock::VerifyAndClearExpectations(context); 3035 Mock::VerifyAndClearExpectations(context);
2993 3036
2994 // When done with it, a sync point should be inserted, but no produce is 3037 // When done with it, a sync point should be inserted, but no produce is
2995 // necessary. 3038 // necessary.
2996 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 3039 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2997 EXPECT_CALL(*context, insertSyncPoint());
2998 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 3040 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
2999 3041
3000 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 3042 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
3001 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 3043 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
3002 } 3044 }
3003 } 3045 }
3004 3046
3005 TEST_P(ResourceProviderTest, 3047 TEST_P(ResourceProviderTest,
3006 TextureMailbox_WaitSyncTokenIfNeeded_WithSyncToken) { 3048 TextureMailbox_WaitSyncTokenIfNeeded_WithSyncToken) {
3007 // Mailboxing is only supported for GL textures. 3049 // Mailboxing is only supported for GL textures.
3008 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE) 3050 if (GetParam() != ResourceProvider::RESOURCE_TYPE_GL_TEXTURE)
3009 return; 3051 return;
3010 3052
3011 scoped_ptr<TextureStateTrackingContext> context_owned( 3053 scoped_ptr<TextureStateTrackingContext> context_owned(
3012 new TextureStateTrackingContext); 3054 new TextureStateTrackingContext);
3013 TextureStateTrackingContext* context = context_owned.get(); 3055 TextureStateTrackingContext* context = context_owned.get();
3014 3056
3015 FakeOutputSurfaceClient output_surface_client; 3057 FakeOutputSurfaceClient output_surface_client;
3016 scoped_ptr<OutputSurface> output_surface( 3058 scoped_ptr<OutputSurface> output_surface(
3017 FakeOutputSurface::Create3d(std::move(context_owned))); 3059 FakeOutputSurface::Create3d(std::move(context_owned)));
3018 CHECK(output_surface->BindToClient(&output_surface_client)); 3060 CHECK(output_surface->BindToClient(&output_surface_client));
3019 3061
3020 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create( 3062 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
3021 output_surface.get(), shared_bitmap_manager_.get(), 3063 output_surface.get(), shared_bitmap_manager_.get(),
3022 gpu_memory_buffer_manager_.get(), NULL, 0, 1, 3064 gpu_memory_buffer_manager_.get(), NULL, 0, 1,
3023 use_gpu_memory_buffer_resources_, use_image_texture_targets_)); 3065 use_gpu_memory_buffer_resources_, use_image_texture_targets_));
3024 3066
3025 gpu::SyncToken sync_token(30); 3067 gpu::SyncToken sync_token(gpu::CommandBufferNamespace::GPU_IO, 0, 0x12, 0x34);
3068 const GLuint64 current_fence_sync = context->GetNextFenceSync();
3026 unsigned target = GL_TEXTURE_2D; 3069 unsigned target = GL_TEXTURE_2D;
3027 3070
3028 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 3071 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
3029 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 3072 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
3030 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
3031 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 3073 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
3032 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 3074 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
3033 3075
3034 gpu::Mailbox gpu_mailbox; 3076 gpu::Mailbox gpu_mailbox;
3035 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); 3077 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
3036 scoped_ptr<SingleReleaseCallbackImpl> callback = 3078 scoped_ptr<SingleReleaseCallbackImpl> callback =
3037 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); 3079 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
3038 3080
3039 TextureMailbox mailbox(gpu_mailbox, sync_token, target); 3081 TextureMailbox mailbox(gpu_mailbox, sync_token, target);
3040 3082
3041 ResourceId id = resource_provider->CreateResourceFromTextureMailbox( 3083 ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
3042 mailbox, std::move(callback)); 3084 mailbox, std::move(callback));
3043 EXPECT_NE(0u, id); 3085 EXPECT_NE(0u, id);
3086 EXPECT_EQ(current_fence_sync, context->GetNextFenceSync());
3044 3087
3045 Mock::VerifyAndClearExpectations(context); 3088 Mock::VerifyAndClearExpectations(context);
3046 3089
3047 { 3090 {
3048 // First call to WaitSyncTokenIfNeeded should call waitSyncToken. 3091 // First call to WaitSyncTokenIfNeeded should call waitSyncToken.
3049 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token))); 3092 EXPECT_CALL(*context, waitSyncToken(MatchesSyncToken(sync_token)));
3050 resource_provider->WaitSyncTokenIfNeeded(id); 3093 resource_provider->WaitSyncTokenIfNeeded(id);
3051 Mock::VerifyAndClearExpectations(context); 3094 Mock::VerifyAndClearExpectations(context);
3052 3095
3053 // Subsequent calls to WaitSyncTokenIfNeeded shouldn't call waitSyncToken. 3096 // Subsequent calls to WaitSyncTokenIfNeeded shouldn't call waitSyncToken.
(...skipping 16 matching lines...) Expand all
3070 scoped_ptr<OutputSurface> output_surface( 3113 scoped_ptr<OutputSurface> output_surface(
3071 FakeOutputSurface::Create3d(std::move(context_owned))); 3114 FakeOutputSurface::Create3d(std::move(context_owned)));
3072 CHECK(output_surface->BindToClient(&output_surface_client)); 3115 CHECK(output_surface->BindToClient(&output_surface_client));
3073 3116
3074 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create( 3117 scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
3075 output_surface.get(), shared_bitmap_manager_.get(), 3118 output_surface.get(), shared_bitmap_manager_.get(),
3076 gpu_memory_buffer_manager_.get(), NULL, 0, 1, 3119 gpu_memory_buffer_manager_.get(), NULL, 0, 1,
3077 use_gpu_memory_buffer_resources_, use_image_texture_targets_)); 3120 use_gpu_memory_buffer_resources_, use_image_texture_targets_));
3078 3121
3079 gpu::SyncToken sync_token; 3122 gpu::SyncToken sync_token;
3123 const GLuint64 current_fence_sync = context->GetNextFenceSync();
3080 unsigned target = GL_TEXTURE_2D; 3124 unsigned target = GL_TEXTURE_2D;
3081 3125
3082 EXPECT_CALL(*context, bindTexture(_, _)).Times(0); 3126 EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
3083 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 3127 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
3084 EXPECT_CALL(*context, insertSyncPoint()).Times(0);
3085 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0); 3128 EXPECT_CALL(*context, produceTextureDirectCHROMIUM(_, _, _)).Times(0);
3086 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0); 3129 EXPECT_CALL(*context, createAndConsumeTextureCHROMIUM(_, _)).Times(0);
3087 3130
3088 gpu::Mailbox gpu_mailbox; 3131 gpu::Mailbox gpu_mailbox;
3089 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1); 3132 memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
3090 scoped_ptr<SingleReleaseCallbackImpl> callback = 3133 scoped_ptr<SingleReleaseCallbackImpl> callback =
3091 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)); 3134 SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
3092 3135
3093 TextureMailbox mailbox(gpu_mailbox, sync_token, target); 3136 TextureMailbox mailbox(gpu_mailbox, sync_token, target);
3094 3137
3095 ResourceId id = resource_provider->CreateResourceFromTextureMailbox( 3138 ResourceId id = resource_provider->CreateResourceFromTextureMailbox(
3096 mailbox, std::move(callback)); 3139 mailbox, std::move(callback));
3097 EXPECT_NE(0u, id); 3140 EXPECT_NE(0u, id);
3141 EXPECT_EQ(current_fence_sync, context->GetNextFenceSync());
3098 3142
3099 Mock::VerifyAndClearExpectations(context); 3143 Mock::VerifyAndClearExpectations(context);
3100 3144
3101 { 3145 {
3102 // WaitSyncTokenIfNeeded with empty sync_token shouldn't call waitSyncToken. 3146 // WaitSyncTokenIfNeeded with empty sync_token shouldn't call waitSyncToken.
3103 EXPECT_CALL(*context, waitSyncToken(_)).Times(0); 3147 EXPECT_CALL(*context, waitSyncToken(_)).Times(0);
3104 resource_provider->WaitSyncTokenIfNeeded(id); 3148 resource_provider->WaitSyncTokenIfNeeded(id);
3105 Mock::VerifyAndClearExpectations(context); 3149 Mock::VerifyAndClearExpectations(context);
3106 } 3150 }
3107 } 3151 }
(...skipping 450 matching lines...) Expand 10 before | Expand all | Expand 10 after
3558 resource_provider->AllocateForTesting(id); 3602 resource_provider->AllocateForTesting(id);
3559 Mock::VerifyAndClearExpectations(context); 3603 Mock::VerifyAndClearExpectations(context);
3560 3604
3561 DCHECK_EQ(10u, context->PeekTextureId()); 3605 DCHECK_EQ(10u, context->PeekTextureId());
3562 resource_provider->DeleteResource(id); 3606 resource_provider->DeleteResource(id);
3563 } 3607 }
3564 } 3608 }
3565 3609
3566 } // namespace 3610 } // namespace
3567 } // namespace cc 3611 } // namespace cc
OLDNEW
« no previous file with comments | « cc/resources/resource_provider.cc ('k') | cc/test/test_gles2_interface.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698