ui/surface/transport_dib.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 UI_SURFACE_TRANSPORT_DIB_H_
   6 #define UI_SURFACE_TRANSPORT_DIB_H_
   7
   8 #include "base/basictypes.h"
   9 #include "ui/surface/surface_export.h"
  10
  11 #if !defined(TOOLKIT_GTK)
  12 #include "base/memory/shared_memory.h"
  13 #endif
  14
  15 #if defined(OS_WIN)
  16 #include <windows.h>
  17 #elif defined(TOOLKIT_GTK) || (defined(OS_LINUX) && defined(USE_AURA))
  18 #include "ui/base/x/x11_util.h"
  19 #endif
  20
  21 class SkCanvas;
  22
  23 // -----------------------------------------------------------------------------
  24 // A TransportDIB is a block of memory that is used to transport pixels
  25 // between processes: from the renderer process to the browser, and
  26 // between renderer and plugin processes.
  27 // -----------------------------------------------------------------------------
  28 class SURFACE_EXPORT TransportDIB {
  29  public:
  30   ~TransportDIB();
  31
  32   // Two typedefs are defined. A Handle is the type which can be sent over
  33   // the wire so that the remote side can map the transport DIB. The Id typedef
  34   // is sufficient to identify the transport DIB when you know that the remote
  35   // side already may have it mapped.
  36 #if defined(OS_WIN)
  37   typedef HANDLE Handle;
  38   // On Windows, the Id type includes a sequence number (epoch) to solve an ABA
  39   // issue:
  40   //   1) Process A creates a transport DIB with HANDLE=1 and sends to B.
  41   //   2) Process B maps the transport DIB and caches 1 -> DIB.
  42   //   3) Process A closes the transport DIB and creates a new one. The new DIB
  43   //      is also assigned HANDLE=1.
  44   //   4) Process A sends the Handle to B, but B incorrectly believes that it
  45   //      already has it cached.
  46   struct HandleAndSequenceNum {
  47     HandleAndSequenceNum()
  48         : handle(NULL),
  49           sequence_num(0) {
  50     }
  51
  52     HandleAndSequenceNum(HANDLE h, uint32 seq_num)
  53         : handle(h),
  54           sequence_num(seq_num) {
  55     }
  56
  57     bool operator==(const HandleAndSequenceNum& other) const {
  58       return other.handle == handle && other.sequence_num == sequence_num;
  59     }
  60
  61     bool operator<(const HandleAndSequenceNum& other) const {
  62       // Use the lexicographic order on the tuple <handle, sequence_num>.
  63       if (other.handle != handle)
  64         return other.handle < handle;
  65       return other.sequence_num < sequence_num;
  66     }
  67
  68     HANDLE handle;
  69     uint32 sequence_num;
  70   };
  71   typedef HandleAndSequenceNum Id;
  72
  73   // Returns a default, invalid handle, that is meant to indicate a missing
  74   // Transport DIB.
  75   static Handle DefaultHandleValue() { return NULL; }
  76
  77   // Returns a value that is ONLY USEFUL FOR TESTS WHERE IT WON'T BE
  78   // ACTUALLY USED AS A REAL HANDLE.
  79   static Handle GetFakeHandleForTest() {
  80     static int fake_handle = 10;
  81     return reinterpret_cast<Handle>(fake_handle++);
  82   }
  83 #elif defined(TOOLKIT_GTK) || (defined(OS_LINUX) && defined(USE_AURA))
  84   typedef int Handle;  // These two ints are SysV IPC shared memory keys
  85   struct Id {
  86     // Ensure that default initialized Ids are invalid.
  87     Id() : shmkey(-1) {
  88     }
  89
  90     bool operator<(const Id& other) const {
  91       return shmkey < other.shmkey;
  92     }
  93
  94     bool operator==(const Id& other) const {
  95       return shmkey == other.shmkey;
  96     }
  97
  98     int shmkey;
  99   };
 100
 101   // Returns a default, invalid handle, that is meant to indicate a missing
 102   // Transport DIB.
 103   static Handle DefaultHandleValue() { return -1; }
 104
 105   // Returns a value that is ONLY USEFUL FOR TESTS WHERE IT WON'T BE
 106   // ACTUALLY USED AS A REAL HANDLE.
 107   static Handle GetFakeHandleForTest() {
 108     static int fake_handle = 10;
 109     return fake_handle++;
 110   }
 111 #else  // OS_POSIX
 112   typedef base::SharedMemoryHandle Handle;
 113   // On POSIX, the inode number of the backing file is used as an id.
 114 #if defined(OS_ANDROID)
 115   typedef base::SharedMemoryHandle Id;
 116 #else
 117   typedef base::SharedMemoryId Id;
 118 #endif
 119
 120   // Returns a default, invalid handle, that is meant to indicate a missing
 121   // Transport DIB.
 122   static Handle DefaultHandleValue() { return Handle(); }
 123
 124   // Returns a value that is ONLY USEFUL FOR TESTS WHERE IT WON'T BE
 125   // ACTUALLY USED AS A REAL HANDLE.
 126   static Handle GetFakeHandleForTest() {
 127     static int fake_handle = 10;
 128     return Handle(fake_handle++, false);
 129   }
 130 #endif
 131
 132   // Create a new TransportDIB, returning NULL on failure.
 133   //
 134   // The size is the minimum size in bytes of the memory backing the transport
 135   // DIB (we may actually allocate more than that to give us better reuse when
 136   // cached).
 137   //
 138   // The sequence number is used to uniquely identify the transport DIB. It
 139   // should be unique for all transport DIBs ever created in the same
 140   // renderer.
 141   static TransportDIB* Create(size_t size, uint32 sequence_num);
 142
 143   // Map the referenced transport DIB.  The caller owns the returned object.
 144   // Returns NULL on failure.
 145   static TransportDIB* Map(Handle transport_dib);
 146
 147   // Create a new |TransportDIB| with a handle to the shared memory. This
 148   // always returns a valid pointer. The DIB is not mapped.
 149   static TransportDIB* CreateWithHandle(Handle handle);
 150
 151   // Returns true if the handle is valid.
 152   static bool is_valid_handle(Handle dib);
 153
 154   // Returns true if the ID refers to a valid dib.
 155   static bool is_valid_id(Id id);
 156
 157   // Returns a canvas using the memory of this TransportDIB. The returned
 158   // pointer will be owned by the caller. The bitmap will be of the given size,
 159   // which should fit inside this memory.
 160   //
 161   // On POSIX, this |TransportDIB| will be mapped if not already. On Windows,
 162   // this |TransportDIB| will NOT be mapped and should not be mapped prior,
 163   // because PlatformCanvas will map the file internally.
 164   //
 165   // Will return NULL on allocation failure. This could be because the image
 166   // is too large to map into the current process' address space.
 167   SkCanvas* GetPlatformCanvas(int w, int h);
 168
 169   // Map the DIB into the current process if it is not already. This is used to
 170   // map a DIB that has already been created. Returns true if the DIB is mapped.
 171   bool Map();
 172
 173   // Return a pointer to the shared memory.
 174   void* memory() const;
 175
 176   // Return the maximum size of the shared memory. This is not the amount of
 177   // data which is valid, you have to know that via other means, this is simply
 178   // the maximum amount that /could/ be valid.
 179   size_t size() const { return size_; }
 180
 181   // Return the identifier which can be used to refer to this shared memory
 182   // on the wire.
 183   Id id() const;
 184
 185   // Return a handle to the underlying shared memory. This can be sent over the
 186   // wire to give this transport DIB to another process.
 187   Handle handle() const;
 188
 189 #if defined(TOOLKIT_GTK) || (defined(OS_LINUX) && defined(USE_AURA))
 190   // Map the shared memory into the X server and return an id for the shared
 191   // segment.
 192   XID MapToX(Display* connection);
 193
 194   void IncreaseInFlightCounter() { inflight_counter_++; }
 195   // Decreases the inflight counter, and deletes the transport DIB if it is
 196   // detached.
 197   void DecreaseInFlightCounter();
 198
 199   // Deletes this transport DIB and detaches the shared memory once the
 200   // |inflight_counter_| is zero.
 201   void Detach();
 202 #endif
 203
 204  private:
 205   TransportDIB();
 206
 207   // Verifies that the dib can hold a canvas of the requested dimensions.
 208   bool VerifyCanvasSize(int w, int h);
 209
 210 #if defined(TOOLKIT_GTK) || (defined(OS_LINUX) && defined(USE_AURA))
 211   Id key_;  // SysV shared memory id
 212   void* address_;  // mapped address
 213   XSharedMemoryId x_shm_;  // X id for the shared segment
 214   Display* display_;  // connection to the X server
 215   size_t inflight_counter_;  // How many requests to the X server are in flight
 216   bool detached_;  // If true, delete the transport DIB when it is idle
 217 #else
 218   explicit TransportDIB(base::SharedMemoryHandle dib);
 219   base::SharedMemory shared_memory_;
 220   uint32 sequence_num_;
 221 #endif
 222   size_t size_;  // length, in bytes
 223
 224   DISALLOW_COPY_AND_ASSIGN(TransportDIB);
 225 };
 226
 227 #endif  // UI_SURFACE_TRANSPORT_DIB_H_