On Windows, create a new TransportDIB::Handle struct which includes the file

app/surface/transport_dib_mac.cc

Index: app/surface/transport_dib_mac.cc
diff --git a/app/surface/transport_dib_mac.cc b/app/surface/transport_dib_mac.cc
index a3eb0bb23075401ff1ddd9768c226a0e5b61ca53..68ccfca4755a6bbf12f6df3b68e1e9e1651526dc 100644
--- a/app/surface/transport_dib_mac.cc
+++ b/app/surface/transport_dib_mac.cc
@@ -13,6 +13,11 @@
 #include "base/shared_memory.h"
 #include "skia/ext/platform_canvas.h"
 
+void TransportDIB::ScopedHandle::Close() {
+  if (is_valid(handle_))
+    base::SharedMemory::CloseHandle(handle_);
+}

[Scott Hess - ex-Googler, 2010/10/25 21:38:19]

AFAICT, handle_ is a file descriptor, and since this doesn't reset to
DefaultHandle(), if Close() is called outside the destructor, it will be called
again in the destructor, which may result in closing someone else's file
descriptor.

Or did I miss something?

See http://crbug.com/60313

[kkania, 2010/10/27 18:12:59]

That is correct. However, since Close() is private and currently called only by
the destructor, it is ok. It might be a good idea to go ahead and reset it
anyways though.

[Scott Hess - ex-Googler, 2010/10/27 19:34:02]

Not if you happen to be multi-threaded.
+1.

+
 TransportDIB::TransportDIB()
     : size_(0) {
 }
@@ -34,46 +39,56 @@ TransportDIB* TransportDIB::Create(size_t size, uint32 sequence_num) {
     return NULL;
   }
 
-  if (!dib->shared_memory_.Map(size)) {
-    delete dib;
-    return NULL;
-  }
-
   dib->size_ = size;
   return dib;
 }
 
 // static
-TransportDIB* TransportDIB::Map(TransportDIB::Handle handle) {
-  if (!is_valid(handle))
+TransportDIB* TransportDIB::Map(Handle handle) {
+  scoped_ptr<TransportDIB> dib(CreateWithHandle(handle));
+  if (!dib->Map())
     return NULL;
+  return dib.release();
+}
 
-  TransportDIB* dib = new TransportDIB(handle);
-  struct stat st;
-  if ((fstat(handle.fd, &st) != 0) ||
-      (!dib->shared_memory_.Map(st.st_size))) {
-    delete dib;
-    if (HANDLE_EINTR(close(handle.fd)) < 0)
-      PLOG(ERROR) << "close";
-    return NULL;
-  }
-
-  dib->size_ = st.st_size;
-
-  return dib;
+// static
+TransportDIB* TransportDIB::CreateWithHandle(Handle handle) {
+  return new TransportDIB(handle);
 }
 
+// static
 bool TransportDIB::is_valid(Handle dib) {
   return dib.fd >= 0;
 }
 
 skia::PlatformCanvas* TransportDIB::GetPlatformCanvas(int w, int h) {
+  if (!memory() && !Map())
+    return NULL;
   scoped_ptr<skia::PlatformCanvas> canvas(new skia::PlatformCanvas);
   if (!canvas->initialize(w, h, true, reinterpret_cast<uint8_t*>(memory())))
     return NULL;
   return canvas.release();
 }
 
+bool TransportDIB::Map() {
+  if (memory())
+    return true;
+
+  struct stat st;
+  if ((fstat(shared_memory_.handle().fd, &st) != 0) ||
+      (!shared_memory_.Map(st.st_size))) {
+    return false;
+  }
+
+  size_ = st.st_size;
+  return true;
+}
+
+TransportDIB::Handle TransportDIB::GetHandleForProcess(
+    base::ProcessHandle process_handle) const {
+  return handle();
+}
+
 void* TransportDIB::memory() const {
   return shared_memory_.memory();
 }