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_BASE_CLIPBOARD_CLIPBOARD_H_
6 #define UI_BASE_CLIPBOARD_CLIPBOARD_H_
7
8 #include <map>
9 #include <string>
10 #include <vector>
11
12 #include "base/compiler_specific.h"
13 #include "base/gtest_prod_util.h"
14 #include "base/memory/scoped_ptr.h"
15 #include "base/memory/shared_memory.h"
16 #include "base/process/process.h"
17 #include "base/strings/string16.h"
18 #include "base/threading/platform_thread.h"
19 #include "base/threading/thread_checker.h"
20 #include "ui/base/clipboard/clipboard_types.h"
21 #include "ui/base/ui_base_export.h"
22
23 #if defined(OS_WIN)
24 #include <objidl.h>
25 #elif defined(OS_ANDROID)
26 #include <jni.h>
27
28 #include "base/android/jni_android.h"
29 #include "base/android/scoped_java_ref.h"
30 #endif
31
32 #if defined(USE_AURA) && defined(USE_X11)
33 #include "base/memory/scoped_ptr.h"
34 #endif
35
36 namespace base {
37 class FilePath;
38
39 namespace win {
40 class MessageWindow;
41 } // namespace win
42 } // namespace base
43
44 // TODO(dcheng): Temporary until the IPC layer doesn't use WriteObjects().
45 namespace content {
46 class ClipboardMessageFilter;
47 }
48
49 namespace gfx {
50 class Size;
51 }
52
53 class SkBitmap;
54
55 #ifdef __OBJC__
56 @class NSString;
57 #else
58 class NSString;
59 #endif
60
61 namespace ui {
62 class ClipboardTest;
63 class ScopedClipboardWriter;
64
NON_EXPORTED_BASE(public base::ThreadChecker)65 class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
66 public:
67 // MIME type constants.
68 static const char kMimeTypeText[];
69 static const char kMimeTypeURIList[];
70 static const char kMimeTypeDownloadURL[];
71 static const char kMimeTypeHTML[];
72 static const char kMimeTypeRTF[];
73 static const char kMimeTypePNG[];
74
75 // Platform neutral holder for native data representation of a clipboard type.
76 struct UI_BASE_EXPORT FormatType {
77 FormatType();
78 ~FormatType();
79
80 // Serializes and deserializes a FormatType for use in IPC messages.
81 std::string Serialize() const;
82 static FormatType Deserialize(const std::string& serialization);
83
84 #if defined(USE_AURA)
85 // FormatType can be used in a set on some platforms.
86 bool operator<(const FormatType& other) const;
87 #endif
88
89 #if defined(OS_WIN)
90 const FORMATETC& ToFormatEtc() const { return data_; }
91 #elif defined(USE_AURA)
92 const std::string& ToString() const { return data_; }
93 #elif defined(OS_MACOSX)
94 // Custom copy and assignment constructor to handle NSString.
95 FormatType(const FormatType& other);
96 FormatType& operator=(const FormatType& other);
97 #endif
98
99 bool Equals(const FormatType& other) const;
100
101 private:
102 friend class Clipboard;
103
104 // Platform-specific glue used internally by the Clipboard class. Each
105 // plaform should define,at least one of each of the following:
106 // 1. A constructor that wraps that native clipboard format descriptor.
107 // 2. An accessor to retrieve the wrapped descriptor.
108 // 3. A data member to hold the wrapped descriptor.
109 //
110 // Note that in some cases, the accessor for the wrapped descriptor may be
111 // public, as these format types can be used by drag and drop code as well.
112 #if defined(OS_WIN)
113 explicit FormatType(UINT native_format);
114 FormatType(UINT native_format, LONG index);
115 UINT ToUINT() const { return data_.cfFormat; }
116 FORMATETC data_;
117 #elif defined(USE_AURA)
118 explicit FormatType(const std::string& native_format);
119 const std::string& data() const { return data_; }
120 std::string data_;
121 #elif defined(OS_MACOSX)
122 explicit FormatType(NSString* native_format);
123 NSString* ToNSString() const { return data_; }
124 NSString* data_;
125 #elif defined(OS_ANDROID)
126 explicit FormatType(const std::string& native_format);
127 const std::string& data() const { return data_; }
128 std::string data_;
129 #else
130 #error No FormatType definition.
131 #endif
132
133 // Copyable and assignable, since this is essentially an opaque value type.
134 };
135
136 // TODO(dcheng): Make this private once the IPC layer no longer needs to
137 // serialize this information.
138 // ObjectType designates the type of data to be stored in the clipboard. This
139 // designation is shared across all OSes. The system-specific designation
140 // is defined by FormatType. A single ObjectType might be represented by
141 // several system-specific FormatTypes. For example, on Linux the CBF_TEXT
142 // ObjectType maps to "text/plain", "STRING", and several other formats. On
143 // windows it maps to CF_UNICODETEXT.
144 enum ObjectType {
145 CBF_TEXT,
146 CBF_HTML,
147 CBF_RTF,
148 CBF_BOOKMARK,
149 CBF_WEBKIT,
150 CBF_SMBITMAP, // Bitmap from shared memory.
151 CBF_DATA, // Arbitrary block of bytes.
152 };
153
154 // ObjectMap is a map from ObjectType to associated data.
155 // The data is organized differently for each ObjectType. The following
156 // table summarizes what kind of data is stored for each key.
157 // * indicates an optional argument.
158 //
159 // Key Arguments Type
160 // -------------------------------------
161 // CBF_TEXT text char array
162 // CBF_HTML html char array
163 // url* char array
164 // CBF_RTF data byte array
165 // CBF_BOOKMARK html char array
166 // url char array
167 // CBF_WEBKIT none empty vector
168 // CBF_SMBITMAP shared_mem A pointer to an unmapped base::SharedMemory
169 // object containing the bitmap data. The bitmap
170 // data should be premultiplied.
171 // size gfx::Size struct
172 // CBF_DATA format char array
173 // data byte array
174 typedef std::vector<char> ObjectMapParam;
175 typedef std::vector<ObjectMapParam> ObjectMapParams;
176 typedef std::map<int /* ObjectType */, ObjectMapParams> ObjectMap;
177
178 static bool IsSupportedClipboardType(int32 type) {
179 switch (type) {
180 case CLIPBOARD_TYPE_COPY_PASTE:
181 return true;
182 #if !defined(OS_WIN) && !defined(OS_MACOSX) && !defined(OS_CHROMEOS)
183 case CLIPBOARD_TYPE_SELECTION:
184 return true;
185 #endif
186 }
187 return false;
188 }
189
190 static ClipboardType FromInt(int32 type) {
191 return static_cast<ClipboardType>(type);
192 }
193
194 // Sets the list of threads that are allowed to access the clipboard.
195 static void SetAllowedThreads(
196 const std::vector<base::PlatformThreadId>& allowed_threads);
197
198 // Returns the clipboard object for the current thread.
199 //
200 // Most implementations will have at most one clipboard which will live on
201 // the main UI thread, but Windows has tricky semantics where there have to
202 // be two clipboards: one that lives on the UI thread and one that lives on
203 // the IO thread.
204 static Clipboard* GetForCurrentThread();
205
206 // Destroys the clipboard for the current thread. Usually, this will clean up
207 // all clipboards, except on Windows. (Previous code leaks the IO thread
208 // clipboard, so it shouldn't be a problem.)
209 static void DestroyClipboardForCurrentThread();
210
211 // Returns a sequence number which uniquely identifies clipboard state.
212 // This can be used to version the data on the clipboard and determine
213 // whether it has changed.
214 uint64 GetSequenceNumber(ClipboardType type);
215
216 // Tests whether the clipboard contains a certain format
217 bool IsFormatAvailable(const FormatType& format, ClipboardType type) const;
218
219 // Clear the clipboard data.
220 void Clear(ClipboardType type);
221
222 void ReadAvailableTypes(ClipboardType type,
223 std::vector<base::string16>* types,
224 bool* contains_filenames) const;
225
226 // Reads UNICODE text from the clipboard, if available.
227 void ReadText(ClipboardType type, base::string16* result) const;
228
229 // Reads ASCII text from the clipboard, if available.
230 void ReadAsciiText(ClipboardType type, std::string* result) const;
231
232 // Reads HTML from the clipboard, if available. If the HTML fragment requires
233 // context to parse, |fragment_start| and |fragment_end| are indexes into
234 // markup indicating the beginning and end of the actual fragment. Otherwise,
235 // they will contain 0 and markup->size().
236 void ReadHTML(ClipboardType type,
237 base::string16* markup,
238 std::string* src_url,
239 uint32* fragment_start,
240 uint32* fragment_end) const;
241
242 // Reads RTF from the clipboard, if available. Stores the result as a byte
243 // vector.
244 void ReadRTF(ClipboardType type, std::string* result) const;
245
246 // Reads an image from the clipboard, if available.
247 SkBitmap ReadImage(ClipboardType type) const;
248
249 void ReadCustomData(ClipboardType clipboard_type,
250 const base::string16& type,
251 base::string16* result) const;
252
253 // Reads a bookmark from the clipboard, if available.
254 void ReadBookmark(base::string16* title, std::string* url) const;
255
256 // Reads raw data from the clipboard with the given format type. Stores result
257 // as a byte vector.
258 void ReadData(const FormatType& format, std::string* result) const;
259
260 // Gets the FormatType corresponding to an arbitrary format string,
261 // registering it with the system if needed. Due to Windows/Linux
262 // limitiations, |format_string| must never be controlled by the user.
263 static FormatType GetFormatType(const std::string& format_string);
264
265 // Get format identifiers for various types.
266 static const FormatType& GetUrlFormatType();
267 static const FormatType& GetUrlWFormatType();
268 static const FormatType& GetMozUrlFormatType();
269 static const FormatType& GetPlainTextFormatType();
270 static const FormatType& GetPlainTextWFormatType();
271 static const FormatType& GetFilenameFormatType();
272 static const FormatType& GetFilenameWFormatType();
273 static const FormatType& GetWebKitSmartPasteFormatType();
274 // Win: MS HTML Format, Other: Generic HTML format
275 static const FormatType& GetHtmlFormatType();
276 static const FormatType& GetRtfFormatType();
277 static const FormatType& GetBitmapFormatType();
278 // TODO(raymes): Unify web custom data and pepper custom data:
279 // crbug.com/158399.
280 static const FormatType& GetWebCustomDataFormatType();
281 static const FormatType& GetPepperCustomDataFormatType();
282
283 // Embeds a pointer to a SharedMemory object pointed to by |bitmap_handle|
284 // belonging to |process| into a shared bitmap [CBF_SMBITMAP] slot in
285 // |objects|. The pointer is deleted by DispatchObjects().
286 //
287 // On non-Windows platforms, |process| is ignored.
288 static bool ReplaceSharedMemHandle(ObjectMap* objects,
289 base::SharedMemoryHandle bitmap_handle,
290 base::ProcessHandle process)
291 WARN_UNUSED_RESULT;
292 #if defined(OS_WIN)
293 // Firefox text/html
294 static const FormatType& GetTextHtmlFormatType();
295 static const FormatType& GetCFHDropFormatType();
296 static const FormatType& GetFileDescriptorFormatType();
297 static const FormatType& GetFileContentZeroFormatType();
298 static const FormatType& GetIDListFormatType();
299 #endif
300
301 private:
302 FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
303 FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
304 friend class ClipboardTest;
305 // For access to WriteObjects().
306 // TODO(dcheng): Remove the temporary exception for content.
307 friend class content::ClipboardMessageFilter;
308 friend class ScopedClipboardWriter;
309
310 Clipboard();
311 ~Clipboard();
312
313 // Write a bunch of objects to the system clipboard. Copies are made of the
314 // contents of |objects|.
315 void WriteObjects(ClipboardType type, const ObjectMap& objects);
316
317 void DispatchObject(ObjectType type, const ObjectMapParams& params);
318
319 void WriteText(const char* text_data, size_t text_len);
320
321 void WriteHTML(const char* markup_data,
322 size_t markup_len,
323 const char* url_data,
324 size_t url_len);
325
326 void WriteRTF(const char* rtf_data, size_t data_len);
327
328 void WriteBookmark(const char* title_data,
329 size_t title_len,
330 const char* url_data,
331 size_t url_len);
332
333 void WriteWebSmartPaste();
334
335 void WriteBitmap(const SkBitmap& bitmap);
336
337 void WriteData(const FormatType& format,
338 const char* data_data,
339 size_t data_len);
340 #if defined(OS_WIN)
341 void WriteBitmapFromHandle(HBITMAP source_hbitmap,
342 const gfx::Size& size);
343
344 // Safely write to system clipboard. Free |handle| on failure.
345 void WriteToClipboard(unsigned int format, HANDLE handle);
346
347 static void ParseBookmarkClipboardFormat(const base::string16& bookmark,
348 base::string16* title,
349 std::string* url);
350
351 // Free a handle depending on its type (as intuited from format)
352 static void FreeData(unsigned int format, HANDLE data);
353
354 // Return the window that should be the clipboard owner, creating it
355 // if neccessary. Marked const for lazily initialization by const methods.
356 HWND GetClipboardWindow() const;
357
358 // Mark this as mutable so const methods can still do lazy initialization.
359 mutable scoped_ptr<base::win::MessageWindow> clipboard_owner_;
360
361 #elif defined(USE_CLIPBOARD_AURAX11)
362 private:
363 // We keep our implementation details private because otherwise we bring in
364 // the X11 headers and break chrome compile.
365 class AuraX11Details;
366 scoped_ptr<AuraX11Details> aurax11_details_;
367 #endif
368
369 DISALLOW_COPY_AND_ASSIGN(Clipboard);
370 };
371
372 } // namespace ui
373
374 #endif // UI_BASE_CLIPBOARD_CLIPBOARD_H_
375