content/common/gpu/gpu_memory_manager_client.h

   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 #if defined(ENABLE_GPU)
   9
  10 #include <list>
  11
  12 #include "base/basictypes.h"
  13 #include "content/common/content_export.h"
  14 #include "content/common/gpu/gpu_memory_allocation.h"
  15 #include "gpu/command_buffer/service/memory_tracking.h"
  16 #include "ui/gfx/size.h"
  17
  18 namespace content {
  19
  20 class GpuMemoryManager;
  21 class GpuMemoryTrackingGroup;
  22
  23 // The interface that the GPU memory manager uses to manipulate a client (to
  24 // send it allocation information and query its properties).
  25 class CONTENT_EXPORT GpuMemoryManagerClient {
  26  public:
  27   virtual ~GpuMemoryManagerClient() {}
  28
  29   // Returns surface size.
  30   virtual gfx::Size GetSurfaceSize() const = 0;
  31
  32   // Returns the memory tracker for this stub.
  33   virtual gpu::gles2::MemoryTracker* GetMemoryTracker() const = 0;
  34
  35   // Sets buffer usage depending on Memory Allocation
  36   virtual void SetMemoryAllocation(
  37       const GpuMemoryAllocation& allocation) = 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 GpuManagedMemoryStats& 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   GpuManagedMemoryStats 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   uint64 bytes_allocation_when_nonvisible_;
  97
  98   // The ideal allocation for this client for three performance levels, used
  99   // transiently during memory policy calculation.
 100   uint64 bytes_allocation_ideal_nicetohave_;
 101   uint64 bytes_allocation_ideal_required_;
 102   uint64 bytes_allocation_ideal_minimum_;
 103
 104   // Set to disable allocating a frontbuffer or to disable allocations
 105   // for clients that don't have surfaces.
 106   bool hibernated_;
 107 };
 108
 109 }  // namespace content
 110
 111 #endif
 112
 113 #endif  // CONTENT_COMMON_GPU_GPU_MEMORY_MANAGER_CLIENT_H_