Rewrite clipboard write IPC handling to be easier to understand.

ui/base/clipboard/clipboard.h

 // Copyright (c) 2012 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 UI_BASE_CLIPBOARD_CLIPBOARD_H_
 #define UI_BASE_CLIPBOARD_CLIPBOARD_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/memory/shared_memory.h"
-#include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_checker.h"
 #include "ui/base/clipboard/clipboard_types.h"
 #include "ui/base/ui_base_export.h"
 
 #if defined(OS_WIN)
 #include <objidl.h>
 #elif defined(OS_ANDROID)
 #include <jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #endif
 
 #if defined(USE_AURA) && defined(USE_X11)
 #include "base/memory/scoped_ptr.h"
 #endif
 
 namespace base {
 class FilePath;
 
 namespace win {
 class MessageWindow;
 }  // namespace win
 }  // namespace base
 
-// TODO(dcheng): Temporary until the IPC layer doesn't use WriteObjects().
-namespace content {
-class ClipboardMessageFilter;
-}
-
 namespace gfx {
 class Size;
 }
 
 class SkBitmap;
 
 #ifdef __OBJC__
 @class NSString;
 #else
 class NSString;
@@ skipping 67 matching lines @@
     explicit FormatType(const std::string& native_format);
     const std::string& data() const { return data_; }
     std::string data_;
 #else
 #error No FormatType definition.
 #endif
 
     // Copyable and assignable, since this is essentially an opaque value type.
   };
 
-  // TODO(dcheng): Make this private once the IPC layer no longer needs to
-  // serialize this information.
-  // ObjectType designates the type of data to be stored in the clipboard. This
-  // designation is shared across all OSes. The system-specific designation
-  // is defined by FormatType. A single ObjectType might be represented by
-  // several system-specific FormatTypes. For example, on Linux the CBF_TEXT
-  // ObjectType maps to "text/plain", "STRING", and several other formats. On
-  // windows it maps to CF_UNICODETEXT.
-  enum ObjectType {
-    CBF_TEXT,
-    CBF_HTML,
-    CBF_RTF,
-    CBF_BOOKMARK,
-    CBF_WEBKIT,
-    CBF_SMBITMAP,  // Bitmap from shared memory.
-    CBF_DATA,  // Arbitrary block of bytes.
-  };
-
-  // ObjectMap is a map from ObjectType to associated data.
-  // The data is organized differently for each ObjectType. The following
-  // table summarizes what kind of data is stored for each key.
-  // * indicates an optional argument.
-  //
-  // Key           Arguments    Type
-  // -------------------------------------
-  // CBF_TEXT      text         char array
-  // CBF_HTML      html         char array
-  //               url*         char array
-  // CBF_RTF       data         byte array
-  // CBF_BOOKMARK  html         char array
-  //               url          char array
-  // CBF_WEBKIT    none         empty vector
-  // CBF_SMBITMAP  shared_mem   A pointer to an unmapped base::SharedMemory
-  //                            object containing the bitmap data. The bitmap
-  //                            data should be premultiplied.
-  //               size         gfx::Size struct
-  // CBF_DATA      format       char array
-  //               data         byte array
-  typedef std::vector<char> ObjectMapParam;
-  typedef std::vector<ObjectMapParam> ObjectMapParams;
-  typedef std::map<int /* ObjectType */, ObjectMapParams> ObjectMap;
-
   static bool IsSupportedClipboardType(int32 type) {
     switch (type) {
       case CLIPBOARD_TYPE_COPY_PASTE:
         return true;
 #if !defined(OS_WIN) && !defined(OS_MACOSX) && !defined(OS_CHROMEOS)
       case CLIPBOARD_TYPE_SELECTION:
         return true;
 #endif
     }
     return false;
@@ skipping 85 matching lines @@
   static const FormatType& GetWebKitSmartPasteFormatType();
   // Win: MS HTML Format, Other: Generic HTML format
   static const FormatType& GetHtmlFormatType();
   static const FormatType& GetRtfFormatType();
   static const FormatType& GetBitmapFormatType();
   // TODO(raymes): Unify web custom data and pepper custom data:
   // crbug.com/158399.
   static const FormatType& GetWebCustomDataFormatType();
   static const FormatType& GetPepperCustomDataFormatType();
 
-  // Embeds a pointer to a SharedMemory object pointed to by |bitmap_handle|
-  // belonging to |process| into a shared bitmap [CBF_SMBITMAP] slot in
-  // |objects|.  The pointer is deleted by DispatchObjects().
-  //
-  // On non-Windows platforms, |process| is ignored.
-  static bool ReplaceSharedMemHandle(ObjectMap* objects,
-                                     base::SharedMemoryHandle bitmap_handle,
-                                     base::ProcessHandle process)
-      WARN_UNUSED_RESULT;
 #if defined(OS_WIN)
   // Firefox text/html
   static const FormatType& GetTextHtmlFormatType();
   static const FormatType& GetCFHDropFormatType();
   static const FormatType& GetFileDescriptorFormatType();
   static const FormatType& GetFileContentZeroFormatType();
   static const FormatType& GetIDListFormatType();
 #endif
 
  private:
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
   FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
   friend class ClipboardTest;
   // For access to WriteObjects().
-  // TODO(dcheng): Remove the temporary exception for content.
-  friend class content::ClipboardMessageFilter;
   friend class ScopedClipboardWriter;
 
   Clipboard();
   ~Clipboard();
 
+  // ObjectType designates the type of data to be stored in the clipboard. This
+  // designation is shared across all OSes. The system-specific designation
+  // is defined by FormatType. A single ObjectType might be represented by
+  // several system-specific FormatTypes. For example, on Linux the CBF_TEXT
+  // ObjectType maps to "text/plain", "STRING", and several other formats. On
+  // windows it maps to CF_UNICODETEXT.
+  enum ObjectType {
+    CBF_TEXT,
+    CBF_HTML,
+    CBF_RTF,
+    CBF_BOOKMARK,
+    CBF_WEBKIT,
+    CBF_SMBITMAP,  // Bitmap from shared memory.
+    CBF_DATA,      // Arbitrary block of bytes.
+  };
+
+  // ObjectMap is a map from ObjectType to associated data.
+  // The data is organized differently for each ObjectType. The following
+  // table summarizes what kind of data is stored for each key.
+  // * indicates an optional argument.
+  //
+  // Key           Arguments    Type
+  // -------------------------------------
+  // CBF_TEXT      text         char array
+  // CBF_HTML      html         char array
+  //               url*         char array
+  // CBF_RTF       data         byte array
+  // CBF_BOOKMARK  html         char array
+  //               url          char array
+  // CBF_WEBKIT    none         empty vector
+  // CBF_SMBITMAP  bitmap       A pointer to a SkBitmap. The caller must ensure

[dcheng, 2014/09/18 17:02:22]

This is really horrible, but I don't want to shave too many yaks at once. I
think I would be willing to argue that this is less horrible than before.

[sky, 2014/09/18 19:47:53]

It's all awful. Are you going to make this less fragile and more type safe? If
so, what is your propsal?

[dcheng, 2014/09/18 21:06:00]

I would like to make it less fragile, but I don't have a solid plan yet. I think
the most logical thing to do would be to reuse DropData instead, but I haven't
figured out an elegant way to graft on clipboard-specific cruft yet (and there's
also drop-specific stuff in there).

+  //                            the SkBitmap remains live for the duration of
+  //                            the WriteObjects call.
+  // CBF_DATA      format       char array
+  //               data         byte array
+  typedef std::vector<char> ObjectMapParam;
+  typedef std::vector<ObjectMapParam> ObjectMapParams;
+  typedef std::map<int /* ObjectType */, ObjectMapParams> ObjectMap;
+
   // Write a bunch of objects to the system clipboard. Copies are made of the
   // contents of |objects|.
   void WriteObjects(ClipboardType type, const ObjectMap& objects);
 
   void DispatchObject(ObjectType type, const ObjectMapParams& params);
 
   void WriteText(const char* text_data, size_t text_len);
 
   void WriteHTML(const char* markup_data,
                  size_t markup_len,
@@ skipping 42 matching lines @@
   class AuraX11Details;
   scoped_ptr<AuraX11Details> aurax11_details_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_