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 "content/browser/renderer_host/software_frame_manager.h" 6 7 #include <vector> 8 9 #include "base/memory/scoped_vector.h" 10 #include "base/memory/shared_memory.h" 11 #include "base/sys_info.h" 12 #include "content/common/host_shared_bitmap_manager.h" 13 #include "testing/gtest/include/gtest/gtest.h" 14 15 namespace content { 16 17 class FakeSoftwareFrameManagerClient : public SoftwareFrameManagerClient { 18 public: 19 FakeSoftwareFrameManagerClient() 20 : evicted_count_(0), weak_ptr_factory_(this) { 21 software_frame_manager_.reset(new SoftwareFrameManager( 22 weak_ptr_factory_.GetWeakPtr())); 23 } 24 virtual ~FakeSoftwareFrameManagerClient() { 25 HostSharedBitmapManager::current()->ProcessRemoved( 26 base::GetCurrentProcessHandle()); 27 } 28 virtual void SoftwareFrameWasFreed(uint32 output_surface_id, 29 unsigned frame_id) OVERRIDE { 30 freed_frames_.push_back(std::make_pair(output_surface_id, frame_id)); 31 } 32 virtual void ReleaseReferencesToSoftwareFrame() OVERRIDE { 33 ++evicted_count_; 34 } 35 36 bool SwapToNewFrame(uint32 output_surface, unsigned frame_id) { 37 cc::SoftwareFrameData frame; 38 frame.id = frame_id; 39 frame.size = gfx::Size(1, 1); 40 frame.damage_rect = gfx::Rect(frame.size); 41 frame.bitmap_id = cc::SharedBitmap::GenerateId(); 42 scoped_ptr<base::SharedMemory> memory = 43 make_scoped_ptr(new base::SharedMemory); 44 memory->CreateAnonymous(4); 45 HostSharedBitmapManager::current()->ChildAllocatedSharedBitmap( 46 4, memory->handle(), base::GetCurrentProcessHandle(), frame.bitmap_id); 47 allocated_memory_.push_back(memory.release()); 48 return software_frame_manager_->SwapToNewFrame( 49 output_surface, &frame, 1.0, base::GetCurrentProcessHandle()); 50 } 51 52 SoftwareFrameManager* software_frame_manager() { 53 return software_frame_manager_.get(); 54 } 55 size_t freed_frame_count() const { return freed_frames_.size(); } 56 size_t evicted_frame_count() const { return evicted_count_; } 57 58 private: 59 std::vector<std::pair<uint32,unsigned> > freed_frames_; 60 size_t evicted_count_; 61 ScopedVector<base::SharedMemory> allocated_memory_; 62 63 scoped_ptr<SoftwareFrameManager> software_frame_manager_; 64 base::WeakPtrFactory<FakeSoftwareFrameManagerClient> 65 weak_ptr_factory_; 66 67 DISALLOW_COPY_AND_ASSIGN(FakeSoftwareFrameManagerClient); 68 }; 69 70 class SoftwareFrameManagerTest : public testing::Test { 71 public: 72 SoftwareFrameManagerTest() {} 73 void AllocateClients(size_t num_clients) { 74 for (size_t i = 0; i < num_clients; ++i) 75 clients_.push_back(new FakeSoftwareFrameManagerClient); 76 } 77 void FreeClients() { 78 for (size_t i = 0; i < clients_.size(); ++i) 79 delete clients_[i]; 80 clients_.clear(); 81 } 82 size_t MaxNumberOfSavedFrames() const { 83 size_t result = 84 RendererFrameManager::GetInstance()->max_number_of_saved_frames(); 85 return result; 86 } 87 88 protected: 89 std::vector<FakeSoftwareFrameManagerClient*> clients_; 90 91 private: 92 DISALLOW_COPY_AND_ASSIGN(SoftwareFrameManagerTest); 93 }; 94 95 TEST_F(SoftwareFrameManagerTest, DoNotEvictVisible) { 96 // Create twice as many frames as are allowed. 97 AllocateClients(2 * MaxNumberOfSavedFrames()); 98 99 // Swap a visible frame to all clients_. Because they are all visible, 100 // the should not be evicted. 101 for (size_t i = 0; i < clients_.size(); ++i) { 102 bool swap_result = clients_[i]->SwapToNewFrame( 103 static_cast<uint32>(i), 0); 104 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 105 EXPECT_TRUE(swap_result); 106 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 107 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 108 } 109 for (size_t i = 0; i < clients_.size(); ++i) { 110 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 111 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 112 } 113 114 // Swap another frame and make sure the original was freed (but not evicted). 115 for (size_t i = 0; i < clients_.size(); ++i) { 116 bool swap_result = clients_[i]->SwapToNewFrame( 117 static_cast<uint32>(i), 1); 118 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 119 EXPECT_TRUE(swap_result); 120 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 121 EXPECT_EQ(1u, clients_[i]->freed_frame_count()); 122 } 123 for (size_t i = 0; i < clients_.size(); ++i) { 124 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 125 EXPECT_EQ(1u, clients_[i]->freed_frame_count()); 126 } 127 128 // Mark the frames as nonvisible and make sure they start getting evicted. 129 for (size_t i = 0; i < clients_.size(); ++i) { 130 clients_[i]->software_frame_manager()->SetVisibility(false); 131 if (clients_.size() - i > MaxNumberOfSavedFrames()) { 132 EXPECT_EQ(1u, clients_[i]->evicted_frame_count()); 133 EXPECT_EQ(2u, clients_[i]->freed_frame_count()); 134 } else { 135 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 136 EXPECT_EQ(1u, clients_[i]->freed_frame_count()); 137 } 138 } 139 140 // Clean up. 141 FreeClients(); 142 } 143 144 TEST_F(SoftwareFrameManagerTest, DoNotEvictDuringSwap) { 145 // Create twice as many frames as are allowed. 146 AllocateClients(2 * MaxNumberOfSavedFrames()); 147 148 // Swap a visible frame to all clients_. Because they are all visible, 149 // the should not be evicted. 150 for (size_t i = 0; i < clients_.size(); ++i) { 151 bool swap_result = clients_[i]->SwapToNewFrame(static_cast<uint32>(i), 0); 152 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 153 EXPECT_TRUE(swap_result); 154 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 155 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 156 } 157 for (size_t i = 0; i < clients_.size(); ++i) { 158 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 159 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 160 } 161 162 // Now create a test non-visible client, and swap a non-visible frame in. 163 scoped_ptr<FakeSoftwareFrameManagerClient> test_client( 164 new FakeSoftwareFrameManagerClient); 165 test_client->software_frame_manager()->SetVisibility(false); 166 { 167 bool swap_result = test_client->SwapToNewFrame( 168 static_cast<uint32>(500), 0); 169 EXPECT_TRUE(swap_result); 170 EXPECT_EQ(0u, test_client->evicted_frame_count()); 171 EXPECT_EQ(0u, test_client->freed_frame_count()); 172 test_client->software_frame_manager()->SwapToNewFrameComplete(false); 173 EXPECT_EQ(1u, test_client->evicted_frame_count()); 174 EXPECT_EQ(1u, test_client->freed_frame_count()); 175 } 176 177 // Clean up. 178 FreeClients(); 179 } 180 181 TEST_F(SoftwareFrameManagerTest, Cleanup) { 182 // Create twice as many frames as are allowed. 183 AllocateClients(2 * MaxNumberOfSavedFrames()); 184 185 // Swap a visible frame to all clients_. Because they are all visible, 186 // the should not be evicted. 187 for (size_t i = 0; i < clients_.size(); ++i) { 188 bool swap_result = clients_[i]->SwapToNewFrame(static_cast<uint32>(i), 0); 189 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 190 EXPECT_TRUE(swap_result); 191 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 192 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 193 } 194 195 // Destroy them. 196 FreeClients(); 197 198 // Create the maximum number of frames, all non-visible. They should not 199 // be evicted, because the previous frames were cleaned up at destruction. 200 AllocateClients(MaxNumberOfSavedFrames()); 201 for (size_t i = 0; i < clients_.size(); ++i) { 202 cc::SoftwareFrameData frame; 203 bool swap_result = clients_[i]->SwapToNewFrame(static_cast<uint32>(i), 0); 204 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 205 EXPECT_TRUE(swap_result); 206 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 207 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 208 } 209 for (size_t i = 0; i < clients_.size(); ++i) { 210 EXPECT_EQ(0u, clients_[i]->evicted_frame_count()); 211 EXPECT_EQ(0u, clients_[i]->freed_frame_count()); 212 } 213 214 // Clean up. 215 FreeClients(); 216 } 217 218 TEST_F(SoftwareFrameManagerTest, EvictVersusFree) { 219 // Create twice as many frames as are allowed and swap a visible frame to all 220 // clients_. Because they are all visible, the should not be evicted. 221 AllocateClients(2 * MaxNumberOfSavedFrames()); 222 for (size_t i = 0; i < clients_.size(); ++i) { 223 clients_[i]->SwapToNewFrame(static_cast<uint32>(i), 0); 224 clients_[i]->software_frame_manager()->SwapToNewFrameComplete(true); 225 } 226 227 // Create a test client with a frame that is not evicted. 228 scoped_ptr<FakeSoftwareFrameManagerClient> test_client( 229 new FakeSoftwareFrameManagerClient); 230 bool swap_result = test_client->SwapToNewFrame(static_cast<uint32>(500), 0); 231 EXPECT_TRUE(swap_result); 232 test_client->software_frame_manager()->SwapToNewFrameComplete(true); 233 EXPECT_EQ(0u, test_client->evicted_frame_count()); 234 EXPECT_EQ(0u, test_client->freed_frame_count()); 235 236 // Take out a reference on the current frame and make the memory manager 237 // evict it. The frame will not be freed until this reference is released. 238 cc::TextureMailbox mailbox; 239 scoped_ptr<cc::SingleReleaseCallback> callback; 240 test_client->software_frame_manager()->GetCurrentFrameMailbox( 241 &mailbox, &callback); 242 test_client->software_frame_manager()->SetVisibility(false); 243 EXPECT_EQ(1u, test_client->evicted_frame_count()); 244 EXPECT_EQ(0u, test_client->freed_frame_count()); 245 246 // Swap a few frames. The frames will be freed as they are swapped out. 247 for (size_t frame = 0; frame < 10; ++frame) { 248 bool swap_result = test_client->SwapToNewFrame( 249 static_cast<uint32>(500), 1 + static_cast<int>(frame)); 250 EXPECT_TRUE(swap_result); 251 test_client->software_frame_manager()->SwapToNewFrameComplete(true); 252 EXPECT_EQ(frame, test_client->freed_frame_count()); 253 EXPECT_EQ(1u, test_client->evicted_frame_count()); 254 } 255 256 // The reference to the frame that we didn't free is in the callback 257 // object. It will go away when the callback is destroyed. 258 EXPECT_EQ(9u, test_client->freed_frame_count()); 259 EXPECT_EQ(1u, test_client->evicted_frame_count()); 260 callback->Run(0, false); 261 callback.reset(); 262 EXPECT_EQ(10u, test_client->freed_frame_count()); 263 EXPECT_EQ(1u, test_client->evicted_frame_count()); 264 265 FreeClients(); 266 } 267 268 } // namespace content 269
