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 "base/memory/shared_memory.h" 10 #include "ui/surface/surface_export.h" 11 12 #if defined(OS_WIN) 13 #include <windows.h> 14 #endif 15 16 class SkCanvas; 17 18 // ----------------------------------------------------------------------------- 19 // A TransportDIB is a block of memory that is used to transport pixels 20 // between processes: from the renderer process to the browser, and 21 // between renderer and plugin processes. 22 // ----------------------------------------------------------------------------- 23 class SURFACE_EXPORT TransportDIB { 24 public: 25 ~TransportDIB(); 26 27 // Two typedefs are defined. A Handle is the type which can be sent over 28 // the wire so that the remote side can map the transport DIB. The Id typedef 29 // is sufficient to identify the transport DIB when you know that the remote 30 // side already may have it mapped. 31 #if defined(OS_WIN) 32 typedef HANDLE Handle; 33 // On Windows, the Id type includes a sequence number (epoch) to solve an ABA 34 // issue: 35 // 1) Process A creates a transport DIB with HANDLE=1 and sends to B. 36 // 2) Process B maps the transport DIB and caches 1 -> DIB. 37 // 3) Process A closes the transport DIB and creates a new one. The new DIB 38 // is also assigned HANDLE=1. 39 // 4) Process A sends the Handle to B, but B incorrectly believes that it 40 // already has it cached. 41 struct HandleAndSequenceNum { 42 HandleAndSequenceNum() 43 : handle(NULL), 44 sequence_num(0) { 45 } 46 47 HandleAndSequenceNum(HANDLE h, uint32 seq_num) 48 : handle(h), 49 sequence_num(seq_num) { 50 } 51 52 bool operator==(const HandleAndSequenceNum& other) const { 53 return other.handle == handle && other.sequence_num == sequence_num; 54 } 55 56 bool operator<(const HandleAndSequenceNum& other) const { 57 // Use the lexicographic order on the tuple <handle, sequence_num>. 58 if (other.handle != handle) 59 return other.handle < handle; 60 return other.sequence_num < sequence_num; 61 } 62 63 HANDLE handle; 64 uint32 sequence_num; 65 }; 66 typedef HandleAndSequenceNum Id; 67 68 // Returns a default, invalid handle, that is meant to indicate a missing 69 // Transport DIB. 70 static Handle DefaultHandleValue() { return NULL; } 71 #else // OS_POSIX 72 typedef base::SharedMemoryHandle Handle; 73 // On POSIX, the inode number of the backing file is used as an id. 74 #if defined(OS_ANDROID) 75 typedef base::SharedMemoryHandle Id; 76 #else 77 typedef base::SharedMemoryId Id; 78 #endif 79 80 // Returns a default, invalid handle, that is meant to indicate a missing 81 // Transport DIB. 82 static Handle DefaultHandleValue() { return Handle(); } 83 #endif 84 85 // Create a new TransportDIB, returning NULL on failure. 86 // 87 // The size is the minimum size in bytes of the memory backing the transport 88 // DIB (we may actually allocate more than that to give us better reuse when 89 // cached). 90 // 91 // The sequence number is used to uniquely identify the transport DIB. It 92 // should be unique for all transport DIBs ever created in the same 93 // renderer. 94 static TransportDIB* Create(size_t size, uint32 sequence_num); 95 96 // Map the referenced transport DIB. The caller owns the returned object. 97 // Returns NULL on failure. 98 static TransportDIB* Map(Handle transport_dib); 99 100 // Create a new |TransportDIB| with a handle to the shared memory. This 101 // always returns a valid pointer. The DIB is not mapped. 102 static TransportDIB* CreateWithHandle(Handle handle); 103 104 // Returns true if the handle is valid. 105 static bool is_valid_handle(Handle dib); 106 107 // Returns true if the ID refers to a valid dib. 108 static bool is_valid_id(Id id); 109 110 // Returns a canvas using the memory of this TransportDIB. The returned 111 // pointer will be owned by the caller. The bitmap will be of the given size, 112 // which should fit inside this memory. 113 // 114 // On POSIX, this |TransportDIB| will be mapped if not already. On Windows, 115 // this |TransportDIB| will NOT be mapped and should not be mapped prior, 116 // because PlatformCanvas will map the file internally. 117 // 118 // Will return NULL on allocation failure. This could be because the image 119 // is too large to map into the current process' address space. 120 SkCanvas* GetPlatformCanvas(int w, int h); 121 122 // Map the DIB into the current process if it is not already. This is used to 123 // map a DIB that has already been created. Returns true if the DIB is mapped. 124 bool Map(); 125 126 // Return a pointer to the shared memory. 127 void* memory() const; 128 129 // Return the maximum size of the shared memory. This is not the amount of 130 // data which is valid, you have to know that via other means, this is simply 131 // the maximum amount that /could/ be valid. 132 size_t size() const { return size_; } 133 134 // Return the identifier which can be used to refer to this shared memory 135 // on the wire. 136 Id id() const; 137 138 // Return a handle to the underlying shared memory. This can be sent over the 139 // wire to give this transport DIB to another process. 140 Handle handle() const; 141 142 private: 143 TransportDIB(); 144 145 // Verifies that the dib can hold a canvas of the requested dimensions. 146 bool VerifyCanvasSize(int w, int h); 147 148 explicit TransportDIB(base::SharedMemoryHandle dib); 149 base::SharedMemory shared_memory_; 150 uint32 sequence_num_; 151 size_t size_; // length, in bytes 152 153 DISALLOW_COPY_AND_ASSIGN(TransportDIB); 154 }; 155 156 #endif // UI_SURFACE_TRANSPORT_DIB_H_ 157
