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 #ifndef CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_CLIENT_H_ 6 #define CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_CLIENT_H_ 7 8 #include <list> 9 10 #include "base/basictypes.h" 11 #include "content/common/content_export.h" 12 #include "gpu/command_buffer/common/gpu_memory_allocation.h" 13 #include "gpu/command_buffer/service/memory_tracking.h" 14 #include "ui/gfx/size.h" 15 16 namespace content { 17 18 class GpuMemoryManager; 19 class GpuMemoryTrackingGroup; 20 21 // The interface that the GPU memory manager uses to manipulate a client (to 22 // send it allocation information and query its properties). 23 class CONTENT_EXPORT GpuMemoryManagerClient { 24 public: 25 virtual ~GpuMemoryManagerClient() {} 26 27 // Returns surface size. 28 virtual gfx::Size GetSurfaceSize() const = 0; 29 30 // Returns the memory tracker for this stub. 31 virtual gpu::gles2::MemoryTracker* GetMemoryTracker() const = 0; 32 33 // Sets buffer usage depending on Memory Allocation 34 virtual void SetMemoryAllocation( 35 const gpu::MemoryAllocation& allocation) = 0; 36 37 virtual void SuggestHaveFrontBuffer(bool suggest_have_frontbuffer) = 0; 38 39 // Returns in bytes the total amount of GPU memory for the GPU which this 40 // context is currently rendering on. Returns false if no extension exists 41 // to get the exact amount of GPU memory. 42 virtual bool GetTotalGpuMemory(uint64* bytes) = 0; 43 }; 44 45 // The state associated with a GPU memory manager client. This acts as the 46 // handle through which the client interacts with the GPU memory manager. 47 class CONTENT_EXPORT GpuMemoryManagerClientState { 48 public: 49 ~GpuMemoryManagerClientState(); 50 void SetVisible(bool visible); 51 void SetManagedMemoryStats(const gpu::ManagedMemoryStats& stats); 52 53 private: 54 friend class GpuMemoryManager; 55 56 GpuMemoryManagerClientState(GpuMemoryManager* memory_manager, 57 GpuMemoryManagerClient* client, 58 GpuMemoryTrackingGroup* tracking_group, 59 bool has_surface, 60 bool visible); 61 62 // The memory manager this client is hanging off of. 63 GpuMemoryManager* memory_manager_; 64 65 // The client to send allocations to. 66 GpuMemoryManagerClient* client_; 67 68 // The tracking group for this client. 69 GpuMemoryTrackingGroup* tracking_group_; 70 71 // Offscreen commandbuffers will not have a surface. 72 const bool has_surface_; 73 74 // Whether or not this client is visible. 75 bool visible_; 76 77 // If the client has a surface, then this is an iterator in the 78 // clients_visible_mru_ if this client is visible and 79 // clients_nonvisible_mru_ if this is non-visible. Otherwise this is an 80 // iterator in clients_nonsurface_. 81 std::list<GpuMemoryManagerClientState*>::iterator list_iterator_; 82 bool list_iterator_valid_; 83 84 // Statistics about memory usage. 85 gpu::ManagedMemoryStats managed_memory_stats_; 86 bool managed_memory_stats_received_; 87 88 // When managed_memory_stats_.bytes_nicetohave leaves the range 89 // [low_, high_], then re-adjust memory limits. 90 uint64 bytes_nicetohave_limit_low_; 91 uint64 bytes_nicetohave_limit_high_; 92 93 // The allocation for this client, used transiently during memory policy 94 // calculation. 95 uint64 bytes_allocation_when_visible_; 96 97 // The ideal allocation for this client for three performance levels, used 98 // transiently during memory policy calculation. 99 uint64 bytes_allocation_ideal_nicetohave_; 100 uint64 bytes_allocation_ideal_required_; 101 uint64 bytes_allocation_ideal_minimum_; 102 103 // Set to disable allocating a frontbuffer or to disable allocations 104 // for clients that don't have surfaces. 105 bool hibernated_; 106 }; 107 108 } // namespace content 109 110 #endif // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_CLIENT_H_ 111