Have ScopedClipboardWriter and Clipboard::WriteObjects take a buffer parameter.

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_
 #pragma once
 
 #include <map>
 #include <string>
@@ skipping 112 matching lines @@
   //                            object containing the bitmap data.
   //               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;
 
   // Buffer designates which clipboard the action should be applied to.
   // Only platforms that use the X Window System support the selection
-  // buffer. Furthermore we currently only use a buffer other than the
-  // standard buffer when reading from the clipboard so only those
-  // functions accept a buffer parameter.
+  // buffer.
   enum Buffer {
     BUFFER_STANDARD,
     BUFFER_SELECTION,
   };
 
   static bool IsValidBuffer(int32 buffer) {
     switch (buffer) {
       case BUFFER_STANDARD:
         return true;
 #if defined(USE_X11) && !defined(USE_AURA)
       case BUFFER_SELECTION:
         return true;
 #endif
     }
     return false;
   }
 
   static Buffer FromInt(int32 buffer) {
     return static_cast<Buffer>(buffer);
   }
 
   Clipboard();
   ~Clipboard();
 
   // Write a bunch of objects to the system clipboard. Copies are made of the
   // contents of |objects|. On Windows they are copied to the system clipboard.
   // On linux they are copied into a structure owned by the Clipboard object and
   // kept until the system clipboard is set again.
-  void WriteObjects(const ObjectMap& objects);
+  void WriteObjects(Buffer buffer, const ObjectMap& objects);
 
   // On Linux/BSD, we need to know when the clipboard is set to a URL.  Most
   // platforms don't care.
 #if defined(OS_WIN) || defined(OS_MACOSX) || defined(USE_AURA)
-  void DidWriteURL(const std::string& utf8_text) {}
+  void DidWriteURL(Buffer buffer, const std::string& utf8_text) {}

[dcheng, 2012/02/03 21:53:58]

It seems like we don't need the buffer parameter since it only applies when we
write to the standard selection (e.g. the pasteboard).

[peter1, 2012/02/04 00:54:46]

We need to check in DidWriteURL that the write was to the clipboard to avoid
overwriting the just-written (and possibly multi-format) primary selection with
a plain text URL, and for that we need the buffer parameter.

[dcheng, 2012/02/04 01:11:05]

Right, but this is only called from ScopedClipboardWriter (and not
ScopedClipboardWriterGlue). ScopedClipboardWriter already knows which buffer
it's writing to, so it can skip the call there can't it?

[peter1, 2012/02/04 02:05:43]

I see.  Well, I don't think it matters too much where we do this test, so I'll
go ahead and move it.

 #else  // !defined(OS_WIN) && !defined(OS_MACOSX)
-  void DidWriteURL(const std::string& utf8_text);
+  void DidWriteURL(Buffer buffer, const std::string& utf8_text);
 #endif
 
   // Returns a sequence number which uniquely identifies clipboard state.
   // This can be used to version the data on the clipboard and determine
   // whether it has changed.
   uint64 GetSequenceNumber(Buffer buffer);
 
   // Tests whether the clipboard contains a certain format
   bool IsFormatAvailable(const FormatType& format, Buffer buffer) const;
 
@@ skipping 122 matching lines @@
   // of data we intend to put on the clipboard on clipboard_data_ as
   // WriteObjects is running, and then at the end call SetGtkClipboard
   // which replaces whatever is on the system clipboard with the
   // contents of clipboard_data_.
 
  public:
   typedef std::map<std::string, std::pair<char*, size_t> > TargetMap;
 
  private:
   // Write changes to gtk clipboard.
-  void SetGtkClipboard();
+  void SetGtkClipboard(Buffer buffer);
   // Insert a mapping into clipboard_data_.
   void InsertMapping(const char* key, char* data, size_t data_len);
 
   // Find the gtk clipboard for the passed buffer enum.
   GtkClipboard* LookupBackingClipboard(Buffer clipboard) const;
 
   TargetMap* clipboard_data_;
   GtkClipboard* clipboard_;
   GtkClipboard* primary_selection_;
 #endif
 
   // MIME type constants.
   static const char kMimeTypeText[];
   static const char kMimeTypeHTML[];
   static const char kMimeTypePNG[];
 
   DISALLOW_COPY_AND_ASSIGN(Clipboard);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_CLIPBOARD_CLIPBOARD_H_