Adds a TransportDIB::Id value that is explicitly invalid and use it when compositing

app/surface/transport_dib.h

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef APP_SURFACE_TRANSPORT_DIB_H_
 #define APP_SURFACE_TRANSPORT_DIB_H_
 #pragma once
 
 #include "base/basictypes.h"
 
@@ skipping 77 matching lines @@
   static Handle DefaultHandleValue() { return Handle(); }
 
   // Returns a value that is ONLY USEFUL FOR TESTS WHERE IT WON'T BE
   // ACTUALLY USED AS A REAL HANDLE.
   static Handle GetFakeHandleForTest() {
     static int fake_handle = 10;
     return Handle(fake_handle++, false);
   }
 #elif defined(USE_X11)
   typedef int Handle;  // These two ints are SysV IPC shared memory keys
-  typedef int Id;
+  struct Id {
+    // Ensure that default initialized Ids are invalid.
+    Id() : shmkey(-1) {
+    }
+
+    bool operator< (const Id& other) const {

[brettw, 2011/03/24 23:54:34]

I think normal style would be no space afer the <

+      return shmkey < other.shmkey;
+    }
+
+    int shmkey;
+  };
 
   // Returns a default, invalid handle, that is meant to indicate a missing
   // Transport DIB.
   static Handle DefaultHandleValue() { return -1; }
 
   // Returns a value that is ONLY USEFUL FOR TESTS WHERE IT WON'T BE
   // ACTUALLY USED AS A REAL HANDLE.
   static Handle GetFakeHandleForTest() {
     static int fake_handle = 10;
     return fake_handle++;
@@ skipping 13 matching lines @@
 
   // Map the referenced transport DIB.  The caller owns the returned object.
   // Returns NULL on failure.
   static TransportDIB* Map(Handle transport_dib);
 
   // Create a new |TransportDIB| with a handle to the shared memory. This
   // always returns a valid pointer. The DIB is not mapped.
   static TransportDIB* CreateWithHandle(Handle handle);
 
   // Returns true if the handle is valid.
-  static bool is_valid(Handle dib);
+  static bool is_valid_handle(Handle dib);
+
+  // Returns true if the ID refers to a valid dib.
+  static bool is_valid_id(Id id);
 
   // Returns a canvas using the memory of this TransportDIB. The returned
   // pointer will be owned by the caller. The bitmap will be of the given size,
   // which should fit inside this memory.
   //
   // On POSIX, this |TransportDIB| will be mapped if not already. On Windows,
   // this |TransportDIB| will NOT be mapped and should not be mapped prior,
   // because PlatformCanvas will map the file internally.
   //
   // Will return NULL on allocation failure. This could be because the image
@@ skipping 26 matching lines @@
   XID MapToX(Display* connection);
 #endif
 
  private:
   TransportDIB();
 #if defined(OS_WIN) || defined(OS_MACOSX)
   explicit TransportDIB(base::SharedMemoryHandle dib);
   base::SharedMemory shared_memory_;
   uint32 sequence_num_;
 #elif defined(USE_X11)
-  int key_;  // SysV shared memory id
+  Id key_;  // SysV shared memory id
   void* address_;  // mapped address
   XSharedMemoryId x_shm_;  // X id for the shared segment
   Display* display_;  // connection to the X server
 #endif
   size_t size_;  // length, in bytes
 
   DISALLOW_COPY_AND_ASSIGN(TransportDIB);
 };
 
 #endif  // APP_SURFACE_TRANSPORT_DIB_H_