Skip to content

GitLab

T
tangled
Commit 24f3d915 authored by dcheng's avatar dcheng Committed by Commit bot
Browse files
Options

Change ui::Clipboard to use virtual methods for testing purposes. 

Platform-specific implementations now have their own derived classes.
This allows some cleanup of platform-specific hackery in clipboard.h,
and paves the way for adding a fake clipboard implementation in the
future for testing.

BUG=319285

Review URL: https://codereview.chromium.org/658963003

Cr-Commit-Position: refs/heads/master@{#300063}
parent a1568366
Hide whitespace changes
Inline Side-by-side
Showing with 776 additions and 431 deletions
ui/base/BUILD.gn
View file @ 24f3d915
...@@ -37,13 +37,15 @@ component("base") { ...@@ -37,13 +37,15 @@ component("base") {
"clipboard/clipboard.cc", "clipboard/clipboard.cc",
"clipboard/clipboard.h", "clipboard/clipboard.h",
"clipboard/clipboard_android.cc", "clipboard/clipboard_android.cc",
"clipboard/clipboard_android_initialization.h", "clipboard/clipboard_android.h",
"clipboard/clipboard_constants.cc", "clipboard/clipboard_constants.cc",
"clipboard/clipboard_mac.h",
"clipboard/clipboard_mac.mm", "clipboard/clipboard_mac.mm",
"clipboard/clipboard_types.h", "clipboard/clipboard_types.h",
"clipboard/clipboard_util_win.cc", "clipboard/clipboard_util_win.cc",
"clipboard/clipboard_util_win.h", "clipboard/clipboard_util_win.h",
"clipboard/clipboard_win.cc", "clipboard/clipboard_win.cc",
"clipboard/clipboard_win.h",
"clipboard/custom_data_helper.cc", "clipboard/custom_data_helper.cc",
"clipboard/custom_data_helper.h", "clipboard/custom_data_helper.h",
"clipboard/custom_data_helper_linux.cc", "clipboard/custom_data_helper_linux.cc",
......
ui/base/android/ui_base_jni_registrar.cc
View file @ 24f3d915
...@@ -8,7 +8,7 @@ ...@@ -8,7 +8,7 @@
#include "base/android/jni_registrar.h" #include "base/android/jni_registrar.h"
#include "ui/base/android/view_android.h" #include "ui/base/android/view_android.h"
#include "ui/base/android/window_android.h" #include "ui/base/android/window_android.h"
#include "ui/base/clipboard/clipboard_android_initialization.h" #include "ui/base/clipboard/clipboard_android.h"
#include "ui/base/device_form_factor_android.h" #include "ui/base/device_form_factor_android.h"
#include "ui/base/l10n/l10n_util_android.h" #include "ui/base/l10n/l10n_util_android.h"
#include "ui/base/resource/resource_bundle_android.h" #include "ui/base/resource/resource_bundle_android.h"
......
ui/base/clipboard/clipboard.cc
View file @ 24f3d915
...@@ -88,7 +88,7 @@ Clipboard* Clipboard::GetForCurrentThread() { ...@@ -88,7 +88,7 @@ Clipboard* Clipboard::GetForCurrentThread() {
if (it != clipboard_map->end()) if (it != clipboard_map->end())
return it->second; return it->second;
Clipboard* clipboard = new ui::Clipboard; Clipboard* clipboard = Clipboard::Create();
clipboard_map->insert(std::make_pair(id, clipboard)); clipboard_map->insert(std::make_pair(id, clipboard));
return clipboard; return clipboard;
} }
......
ui/base/clipboard/clipboard.h
View file @ 24f3d915
...@@ -11,7 +11,6 @@ ...@@ -11,7 +11,6 @@
#include "base/compiler_specific.h" #include "base/compiler_specific.h"
#include "base/gtest_prod_util.h" #include "base/gtest_prod_util.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/shared_memory.h" #include "base/memory/shared_memory.h"
#include "base/process/process.h" #include "base/process/process.h"
#include "base/strings/string16.h" #include "base/strings/string16.h"
...@@ -22,15 +21,6 @@ ...@@ -22,15 +21,6 @@
#if defined(OS_WIN) #if defined(OS_WIN)
#include <objidl.h> #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 #endif
namespace base { namespace base {
...@@ -88,7 +78,7 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) { ...@@ -88,7 +78,7 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
#if defined(OS_WIN) #if defined(OS_WIN)
const FORMATETC& ToFormatEtc() const { return data_; } const FORMATETC& ToFormatEtc() const { return data_; }
#elif defined(USE_AURA) #elif defined(USE_AURA) || defined(OS_ANDROID)
const std::string& ToString() const { return data_; } const std::string& ToString() const { return data_; }
#elif defined(OS_MACOSX) #elif defined(OS_MACOSX)
NSString* ToNSString() const { return data_; } NSString* ToNSString() const { return data_; }
...@@ -113,19 +103,13 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) { ...@@ -113,19 +103,13 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
#if defined(OS_WIN) #if defined(OS_WIN)
explicit FormatType(UINT native_format); explicit FormatType(UINT native_format);
FormatType(UINT native_format, LONG index); FormatType(UINT native_format, LONG index);
UINT ToUINT() const { return data_.cfFormat; }
FORMATETC data_; FORMATETC data_;
#elif defined(USE_AURA) #elif defined(USE_AURA) || defined(OS_ANDROID)
explicit FormatType(const std::string& native_format); explicit FormatType(const std::string& native_format);
const std::string& data() const { return data_; }
std::string data_; std::string data_;
#elif defined(OS_MACOSX) #elif defined(OS_MACOSX)
explicit FormatType(NSString* native_format); explicit FormatType(NSString* native_format);
NSString* data_; NSString* data_;
#elif defined(OS_ANDROID)
explicit FormatType(const std::string& native_format);
const std::string& data() const { return data_; }
std::string data_;
#else #else
#error No FormatType definition. #error No FormatType definition.
#endif #endif
...@@ -211,51 +195,53 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) { ...@@ -211,51 +195,53 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
// Returns a sequence number which uniquely identifies clipboard state. // Returns a sequence number which uniquely identifies clipboard state.
// This can be used to version the data on the clipboard and determine // This can be used to version the data on the clipboard and determine
// whether it has changed. // whether it has changed.
uint64 GetSequenceNumber(ClipboardType type); virtual uint64 GetSequenceNumber(ClipboardType type) = 0;
// Tests whether the clipboard contains a certain format // Tests whether the clipboard contains a certain format
bool IsFormatAvailable(const FormatType& format, ClipboardType type) const; virtual bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const = 0;
// Clear the clipboard data. // Clear the clipboard data.
void Clear(ClipboardType type); virtual void Clear(ClipboardType type) = 0;
void ReadAvailableTypes(ClipboardType type, virtual void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const; bool* contains_filenames) const = 0;
// Reads UNICODE text from the clipboard, if available. // Reads UNICODE text from the clipboard, if available.
void ReadText(ClipboardType type, base::string16* result) const; virtual void ReadText(ClipboardType type, base::string16* result) const = 0;
// Reads ASCII text from the clipboard, if available. // Reads ASCII text from the clipboard, if available.
void ReadAsciiText(ClipboardType type, std::string* result) const; virtual void ReadAsciiText(ClipboardType type, std::string* result) const = 0;
// Reads HTML from the clipboard, if available. If the HTML fragment requires // Reads HTML from the clipboard, if available. If the HTML fragment requires
// context to parse, |fragment_start| and |fragment_end| are indexes into // context to parse, |fragment_start| and |fragment_end| are indexes into
// markup indicating the beginning and end of the actual fragment. Otherwise, // markup indicating the beginning and end of the actual fragment. Otherwise,
// they will contain 0 and markup->size(). // they will contain 0 and markup->size().
void ReadHTML(ClipboardType type, virtual void ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const; uint32* fragment_end) const = 0;
// Reads RTF from the clipboard, if available. Stores the result as a byte // Reads RTF from the clipboard, if available. Stores the result as a byte
// vector. // vector.
void ReadRTF(ClipboardType type, std::string* result) const; virtual void ReadRTF(ClipboardType type, std::string* result) const = 0;
// Reads an image from the clipboard, if available. // Reads an image from the clipboard, if available.
SkBitmap ReadImage(ClipboardType type) const; virtual SkBitmap ReadImage(ClipboardType type) const = 0;
void ReadCustomData(ClipboardType clipboard_type, virtual void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const; base::string16* result) const = 0;
// Reads a bookmark from the clipboard, if available. // Reads a bookmark from the clipboard, if available.
void ReadBookmark(base::string16* title, std::string* url) const; virtual void ReadBookmark(base::string16* title, std::string* url) const = 0;
// Reads raw data from the clipboard with the given format type. Stores result // Reads raw data from the clipboard with the given format type. Stores result
// as a byte vector. // as a byte vector.
void ReadData(const FormatType& format, std::string* result) const; virtual void ReadData(const FormatType& format,
std::string* result) const = 0;
// Gets the FormatType corresponding to an arbitrary format string, // Gets the FormatType corresponding to an arbitrary format string,
// registering it with the system if needed. Due to Windows/Linux // registering it with the system if needed. Due to Windows/Linux
...@@ -298,73 +284,48 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) { ...@@ -298,73 +284,48 @@ class UI_BASE_EXPORT Clipboard : NON_EXPORTED_BASE(public base::ThreadChecker) {
static const FormatType& GetIDListFormatType(); static const FormatType& GetIDListFormatType();
#endif #endif
private: protected:
FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest); static Clipboard* Create();
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() {}
~Clipboard(); virtual ~Clipboard() {}
// Write a bunch of objects to the system clipboard. Copies are made of the // Write a bunch of objects to the system clipboard. Copies are made of the
// contents of |objects|. // contents of |objects|.
void WriteObjects(ClipboardType type, const ObjectMap& objects); virtual void WriteObjects(ClipboardType type, const ObjectMap& objects) = 0;
void DispatchObject(ObjectType type, const ObjectMapParams& params); void DispatchObject(ObjectType type, const ObjectMapParams& params);
void WriteText(const char* text_data, size_t text_len); virtual void WriteText(const char* text_data, size_t text_len) = 0;
void WriteHTML(const char* markup_data, virtual void WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len); size_t url_len) = 0;
void WriteRTF(const char* rtf_data, size_t data_len); virtual void WriteRTF(const char* rtf_data, size_t data_len) = 0;
void WriteBookmark(const char* title_data, virtual void WriteBookmark(const char* title_data,
size_t title_len, size_t title_len,
const char* url_data, const char* url_data,
size_t url_len); size_t url_len) = 0;
void WriteWebSmartPaste(); virtual void WriteWebSmartPaste() = 0;
void WriteBitmap(const SkBitmap& bitmap); virtual void WriteBitmap(const SkBitmap& bitmap) = 0;
void WriteData(const FormatType& format, virtual void WriteData(const FormatType& format,
const char* data_data, const char* data_data,
size_t data_len); size_t data_len) = 0;
#if defined(OS_WIN)
void WriteBitmapFromHandle(HBITMAP source_hbitmap,
const gfx::Size& size);
// Safely write to system clipboard. Free |handle| on failure.
void WriteToClipboard(unsigned int format, HANDLE handle);
static void ParseBookmarkClipboardFormat(const base::string16& bookmark,
base::string16* title,
std::string* url);
// Free a handle depending on its type (as intuited from format)
static void FreeData(unsigned int format, HANDLE data);
// Return the window that should be the clipboard owner, creating it
// if neccessary. Marked const for lazily initialization by const methods.
HWND GetClipboardWindow() const;
// Mark this as mutable so const methods can still do lazy initialization.
mutable scoped_ptr<base::win::MessageWindow> clipboard_owner_;
#elif defined(USE_CLIPBOARD_AURAX11)
private: private:
// We keep our implementation details private because otherwise we bring in FRIEND_TEST_ALL_PREFIXES(ClipboardTest, SharedBitmapTest);
// the X11 headers and break chrome compile. FRIEND_TEST_ALL_PREFIXES(ClipboardTest, EmptyHTMLTest);
class AuraX11Details; friend class ClipboardTest;
scoped_ptr<AuraX11Details> aurax11_details_; // For access to WriteObjects().
#endif // TODO(dcheng): Remove the temporary exception for content.
friend class content::ClipboardMessageFilter;
friend class ScopedClipboardWriter;
DISALLOW_COPY_AND_ASSIGN(Clipboard); DISALLOW_COPY_AND_ASSIGN(Clipboard);
}; };
......
ui/base/clipboard/clipboard_android.cc
View file @ 24f3d915
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
#include "ui/base/clipboard/clipboard.h" #include "ui/base/clipboard/clipboard_android.h"
#include "base/android/jni_string.h" #include "base/android/jni_string.h"
#include "base/lazy_instance.h" #include "base/lazy_instance.h"
...@@ -11,7 +11,6 @@ ...@@ -11,7 +11,6 @@
#include "base/synchronization/lock.h" #include "base/synchronization/lock.h"
#include "jni/Clipboard_jni.h" #include "jni/Clipboard_jni.h"
#include "third_party/skia/include/core/SkBitmap.h" #include "third_party/skia/include/core/SkBitmap.h"
#include "ui/base/clipboard/clipboard_android_initialization.h"
#include "ui/gfx/size.h" #include "ui/gfx/size.h"
// TODO:(andrewhayden) Support additional formats in Android: Bitmap, URI, HTML, // TODO:(andrewhayden) Support additional formats in Android: Bitmap, URI, HTML,
...@@ -258,16 +257,22 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() { ...@@ -258,16 +257,22 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
return type; return type;
} }
// Clipboard implementation. // Clipboard factory method.
Clipboard::Clipboard() { // static
Clipboard* Clipboard::Create() {
return new ClipboardAndroid;
}
// ClipboardAndroid implementation.
ClipboardAndroid::ClipboardAndroid() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
} }
Clipboard::~Clipboard() { ClipboardAndroid::~ClipboardAndroid() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
} }
uint64 Clipboard::GetSequenceNumber(ClipboardType /* type */) { uint64 ClipboardAndroid::GetSequenceNumber(ClipboardType /* type */) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
// TODO: implement this. For now this interface will advertise // TODO: implement this. For now this interface will advertise
// that the clipboard never changes. That's fine as long as we // that the clipboard never changes. That's fine as long as we
...@@ -275,22 +280,22 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType /* type */) { ...@@ -275,22 +280,22 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType /* type */) {
return 0; return 0;
} }
bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format, bool ClipboardAndroid::IsFormatAvailable(const Clipboard::FormatType& format,
ClipboardType type) const { ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
return g_map.Get().HasFormat(format.data()); return g_map.Get().HasFormat(format.ToString());
} }
void Clipboard::Clear(ClipboardType type) { void ClipboardAndroid::Clear(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
g_map.Get().Clear(); g_map.Get().Clear();
} }
void Clipboard::ReadAvailableTypes(ClipboardType type, void ClipboardAndroid::ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const { bool* contains_filenames) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -305,7 +310,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -305,7 +310,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
*contains_filenames = false; *contains_filenames = false;
} }
void Clipboard::ReadText(ClipboardType type, base::string16* result) const { void ClipboardAndroid::ReadText(ClipboardType type,
base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
std::string utf8; std::string utf8;
...@@ -313,18 +319,19 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const { ...@@ -313,18 +319,19 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
*result = base::UTF8ToUTF16(utf8); *result = base::UTF8ToUTF16(utf8);
} }
void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { void ClipboardAndroid::ReadAsciiText(ClipboardType type,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
*result = g_map.Get().Get(kPlainTextFormat); *result = g_map.Get().Get(kPlainTextFormat);
} }
// Note: |src_url| isn't really used. It is only implemented in Windows // Note: |src_url| isn't really used. It is only implemented in Windows
void Clipboard::ReadHTML(ClipboardType type, void ClipboardAndroid::ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const { uint32* fragment_end) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
if (src_url) if (src_url)
...@@ -337,12 +344,12 @@ void Clipboard::ReadHTML(ClipboardType type, ...@@ -337,12 +344,12 @@ void Clipboard::ReadHTML(ClipboardType type,
*fragment_end = static_cast<uint32>(markup->length()); *fragment_end = static_cast<uint32>(markup->length());
} }
void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { void ClipboardAndroid::ReadRTF(ClipboardType type, std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
NOTIMPLEMENTED(); NOTIMPLEMENTED();
} }
SkBitmap Clipboard::ReadImage(ClipboardType type) const { SkBitmap ClipboardAndroid::ReadImage(ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
std::string input = g_map.Get().Get(kBitmapFormat); std::string input = g_map.Get().Get(kBitmapFormat);
...@@ -361,66 +368,70 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const { ...@@ -361,66 +368,70 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const {
return bmp; return bmp;
} }
void Clipboard::ReadCustomData(ClipboardType clipboard_type, void ClipboardAndroid::ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const { base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
NOTIMPLEMENTED(); NOTIMPLEMENTED();
} }
void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { void ClipboardAndroid::ReadBookmark(base::string16* title,
std::string* url) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
NOTIMPLEMENTED(); NOTIMPLEMENTED();
} }
void Clipboard::ReadData(const Clipboard::FormatType& format, void ClipboardAndroid::ReadData(const Clipboard::FormatType& format,
std::string* result) const { std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
*result = g_map.Get().Get(format.data()); *result = g_map.Get().Get(format.ToString());
} }
// Main entry point used to write several values in the clipboard. // Main entry point used to write several values in the clipboard.
void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { void ClipboardAndroid::WriteObjects(ClipboardType type,
const ObjectMap& objects) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
g_map.Get().Clear(); g_map.Get().Clear();
for (ObjectMap::const_iterator iter = objects.begin(); for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
iter != objects.end(); ++iter) { ++iter) {
DispatchObject(static_cast<ObjectType>(iter->first), iter->second); DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
} }
} }
void Clipboard::WriteText(const char* text_data, size_t text_len) { void ClipboardAndroid::WriteText(const char* text_data, size_t text_len) {
g_map.Get().Set(kPlainTextFormat, std::string(text_data, text_len)); g_map.Get().Set(kPlainTextFormat, std::string(text_data, text_len));
} }
void Clipboard::WriteHTML(const char* markup_data, void ClipboardAndroid::WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
g_map.Get().Set(kHTMLFormat, std::string(markup_data, markup_len)); g_map.Get().Set(kHTMLFormat, std::string(markup_data, markup_len));
} }
void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) { void ClipboardAndroid::WriteRTF(const char* rtf_data, size_t data_len) {
NOTIMPLEMENTED(); NOTIMPLEMENTED();
} }
// Note: according to other platforms implementations, this really writes the // Note: according to other platforms implementations, this really writes the
// URL spec. // URL spec.
void Clipboard::WriteBookmark(const char* title_data, size_t title_len, void ClipboardAndroid::WriteBookmark(const char* title_data,
const char* url_data, size_t url_len) { size_t title_len,
const char* url_data,
size_t url_len) {
g_map.Get().Set(kBookmarkFormat, std::string(url_data, url_len)); g_map.Get().Set(kBookmarkFormat, std::string(url_data, url_len));
} }
// Write an extra flavor that signifies WebKit was the last to modify the // Write an extra flavor that signifies WebKit was the last to modify the
// pasteboard. This flavor has no data. // pasteboard. This flavor has no data.
void Clipboard::WriteWebSmartPaste() { void ClipboardAndroid::WriteWebSmartPaste() {
g_map.Get().Set(kWebKitSmartPasteFormat, std::string()); g_map.Get().Set(kWebKitSmartPasteFormat, std::string());
} }
// Note: we implement this to pass all unit tests but it is currently unclear // Note: we implement this to pass all unit tests but it is currently unclear
// how some code would consume this. // how some code would consume this.
void Clipboard::WriteBitmap(const SkBitmap& bitmap) { void ClipboardAndroid::WriteBitmap(const SkBitmap& bitmap) {
gfx::Size size(bitmap.width(), bitmap.height()); gfx::Size size(bitmap.width(), bitmap.height());
std::string packed(reinterpret_cast<const char*>(&size), sizeof(size)); std::string packed(reinterpret_cast<const char*>(&size), sizeof(size));
...@@ -432,12 +443,12 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) { ...@@ -432,12 +443,12 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
g_map.Get().Set(kBitmapFormat, packed); g_map.Get().Set(kBitmapFormat, packed);
} }
void Clipboard::WriteData(const Clipboard::FormatType& format, void ClipboardAndroid::WriteData(const Clipboard::FormatType& format,
const char* data_data, size_t data_len) { const char* data_data,
g_map.Get().Set(format.data(), std::string(data_data, data_len)); size_t data_len) {
g_map.Get().Set(format.ToString(), std::string(data_data, data_len));
} }
// See clipboard_android_initialization.h for more information.
bool RegisterClipboardAndroid(JNIEnv* env) { bool RegisterClipboardAndroid(JNIEnv* env) {
return RegisterNativesImpl(env); return RegisterNativesImpl(env);
} }
......
ui/base/clipboard/clipboard_android.h 0 → 100644
View file @ 24f3d915
// Copyright 2014 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_ANDROID_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_H_
#include "ui/base/clipboard/clipboard.h"
#include <jni.h>
namespace ui {
bool RegisterClipboardAndroid(JNIEnv* env);
class ClipboardAndroid : public Clipboard {
private:
friend class Clipboard;
ClipboardAndroid();
~ClipboardAndroid() override;
// Clipboard overrides:
uint64 GetSequenceNumber(ClipboardType type) override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) const override;
void ReadText(ClipboardType type, base::string16* result) const override;
void ReadAsciiText(ClipboardType type, std::string* result) const override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
uint32* fragment_start,
uint32* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type,
base::string16* result) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
void ReadData(const FormatType& format, std::string* result) const override;
void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
void WriteText(const char* text_data, size_t text_len) override;
void WriteHTML(const char* markup_data,
size_t markup_len,
const char* url_data,
size_t url_len) override;
void WriteRTF(const char* rtf_data, size_t data_len) override;
void WriteBookmark(const char* title_data,
size_t title_len,
const char* url_data,
size_t url_len) override;
void WriteWebSmartPaste() override;
void WriteBitmap(const SkBitmap& bitmap) override;
void WriteData(const FormatType& format,
const char* data_data,
size_t data_len) override;
DISALLOW_COPY_AND_ASSIGN(ClipboardAndroid);
};
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_H_
ui/base/clipboard/clipboard_android_initialization.h deleted 100644 → 0
View file @ a1568366
// Copyright (c) 2013 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.
// This file exists to help bind the Android clipboard implementation's JNI
// methods statically. Since the JNI header file that contains the static
// registration method is autogenerated and since the general clipboard.h
// file is platform-independent, a new header file (this) is the cleanest
// option for holding this function (as it is specific to Android).
#ifndef UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_
#include <jni.h>
namespace ui {
bool RegisterClipboardAndroid(JNIEnv* env);
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_ANDROID_INITIALIZATION_H_
ui/base/clipboard/clipboard_aura.cc
View file @ 24f3d915
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
#include "ui/base/clipboard/clipboard.h" #include "ui/base/clipboard/clipboard_aura.h"
#include <list> #include <list>
...@@ -406,7 +406,7 @@ ClipboardData* ClipboardDataBuilder::current_data_ = NULL; ...@@ -406,7 +406,7 @@ ClipboardData* ClipboardDataBuilder::current_data_ = NULL;
} // namespace } // namespace
// Clipboard FormatType implementation. // Clipboard::FormatType implementation.
Clipboard::FormatType::FormatType() { Clipboard::FormatType::FormatType() {
} }
...@@ -511,25 +511,30 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() { ...@@ -511,25 +511,30 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
return type; return type;
} }
// Clipboard implementation. // Clipboard factory method.
Clipboard::Clipboard() { Clipboard* Clipboard::Create() {
return new ClipboardAura;
}
// ClipboardAura implementation.
ClipboardAura::ClipboardAura() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
// Make sure clipboard is created. // Make sure clipboard is created.
GetClipboard(); GetClipboard();
} }
Clipboard::~Clipboard() { ClipboardAura::~ClipboardAura() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DeleteClipboard(); DeleteClipboard();
} }
uint64 Clipboard::GetSequenceNumber(ClipboardType type) { uint64 ClipboardAura::GetSequenceNumber(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
return GetClipboard()->sequence_number(); return GetClipboard()->sequence_number();
} }
bool Clipboard::IsFormatAvailable(const FormatType& format, bool ClipboardAura::IsFormatAvailable(const FormatType& format,
ClipboardType type) const { ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
AuraClipboard* clipboard = GetClipboard(); AuraClipboard* clipboard = GetClipboard();
...@@ -552,16 +557,16 @@ bool Clipboard::IsFormatAvailable(const FormatType& format, ...@@ -552,16 +557,16 @@ bool Clipboard::IsFormatAvailable(const FormatType& format,
return false; return false;
} }
void Clipboard::Clear(ClipboardType type) { void ClipboardAura::Clear(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
AuraClipboard* clipboard = GetClipboard(); AuraClipboard* clipboard = GetClipboard();
clipboard->Clear(); clipboard->Clear();
} }
void Clipboard::ReadAvailableTypes(ClipboardType type, void ClipboardAura::ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const { bool* contains_filenames) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
if (!types || !contains_filenames) { if (!types || !contains_filenames) {
NOTREACHED(); NOTREACHED();
...@@ -586,95 +591,98 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -586,95 +591,98 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
} }
} }
void Clipboard::ReadText(ClipboardType type, base::string16* result) const { void ClipboardAura::ReadText(ClipboardType type, base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadText(result); GetClipboard()->ReadText(result);
} }
void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { void ClipboardAura::ReadAsciiText(ClipboardType type,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadAsciiText(result); GetClipboard()->ReadAsciiText(result);
} }
void Clipboard::ReadHTML(ClipboardType type, void ClipboardAura::ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const { uint32* fragment_end) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end); GetClipboard()->ReadHTML(markup, src_url, fragment_start, fragment_end);
} }
void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { void ClipboardAura::ReadRTF(ClipboardType type, std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadRTF(result); GetClipboard()->ReadRTF(result);
} }
SkBitmap Clipboard::ReadImage(ClipboardType type) const { SkBitmap ClipboardAura::ReadImage(ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
return GetClipboard()->ReadImage(); return GetClipboard()->ReadImage();
} }
void Clipboard::ReadCustomData(ClipboardType clipboard_type, void ClipboardAura::ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const { base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadCustomData(type, result); GetClipboard()->ReadCustomData(type, result);
} }
void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { void ClipboardAura::ReadBookmark(base::string16* title,
std::string* url) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadBookmark(title, url); GetClipboard()->ReadBookmark(title, url);
} }
void Clipboard::ReadData(const FormatType& format, std::string* result) const { void ClipboardAura::ReadData(const FormatType& format,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
GetClipboard()->ReadData(format.ToString(), result); GetClipboard()->ReadData(format.ToString(), result);
} }
void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { void ClipboardAura::WriteObjects(ClipboardType type, const ObjectMap& objects) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
for (ObjectMap::const_iterator iter = objects.begin(); for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
iter != objects.end(); ++iter) { ++iter) {
DispatchObject(static_cast<ObjectType>(iter->first), iter->second); DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
} }
ClipboardDataBuilder::CommitToClipboard(); ClipboardDataBuilder::CommitToClipboard();
} }
void Clipboard::WriteText(const char* text_data, size_t text_len) { void ClipboardAura::WriteText(const char* text_data, size_t text_len) {
ClipboardDataBuilder::WriteText(text_data, text_len); ClipboardDataBuilder::WriteText(text_data, text_len);
} }
void Clipboard::WriteHTML(const char* markup_data, void ClipboardAura::WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
ClipboardDataBuilder::WriteHTML(markup_data, markup_len, url_data, url_len); ClipboardDataBuilder::WriteHTML(markup_data, markup_len, url_data, url_len);
} }
void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) { void ClipboardAura::WriteRTF(const char* rtf_data, size_t data_len) {
ClipboardDataBuilder::WriteRTF(rtf_data, data_len); ClipboardDataBuilder::WriteRTF(rtf_data, data_len);
} }
void Clipboard::WriteBookmark(const char* title_data, void ClipboardAura::WriteBookmark(const char* title_data,
size_t title_len, size_t title_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
ClipboardDataBuilder::WriteBookmark(title_data, title_len, url_data, url_len); ClipboardDataBuilder::WriteBookmark(title_data, title_len, url_data, url_len);
} }
void Clipboard::WriteWebSmartPaste() { void ClipboardAura::WriteWebSmartPaste() {
ClipboardDataBuilder::WriteWebSmartPaste(); ClipboardDataBuilder::WriteWebSmartPaste();
} }
void Clipboard::WriteBitmap(const SkBitmap& bitmap) { void ClipboardAura::WriteBitmap(const SkBitmap& bitmap) {
ClipboardDataBuilder::WriteBitmap(bitmap); ClipboardDataBuilder::WriteBitmap(bitmap);
} }
void Clipboard::WriteData(const FormatType& format, void ClipboardAura::WriteData(const FormatType& format,
const char* data_data, const char* data_data,
size_t data_len) { size_t data_len) {
ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len); ClipboardDataBuilder::WriteData(format.ToString(), data_data, data_len);
} }
......
ui/base/clipboard/clipboard_aura.h 0 → 100644
View file @ 24f3d915
// Copyright 2014 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_AURA_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_AURA_H_
#include "ui/base/clipboard/clipboard.h"
namespace ui {
class ClipboardAura : public Clipboard {
private:
friend class Clipboard;
ClipboardAura();
~ClipboardAura() override;
// Clipboard overrides:
uint64 GetSequenceNumber(ClipboardType type) override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) const override;
void ReadText(ClipboardType type, base::string16* result) const override;
void ReadAsciiText(ClipboardType type, std::string* result) const override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
uint32* fragment_start,
uint32* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type,
base::string16* result) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
void ReadData(const FormatType& format, std::string* result) const override;
void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
void WriteText(const char* text_data, size_t text_len) override;
void WriteHTML(const char* markup_data,
size_t markup_len,
const char* url_data,
size_t url_len) override;
void WriteRTF(const char* rtf_data, size_t data_len) override;
void WriteBookmark(const char* title_data,
size_t title_len,
const char* url_data,
size_t url_len) override;
void WriteWebSmartPaste() override;
void WriteBitmap(const SkBitmap& bitmap) override;
void WriteData(const FormatType& format,
const char* data_data,
size_t data_len) override;
DISALLOW_COPY_AND_ASSIGN(ClipboardAura);
};
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_AURA_H_
ui/base/clipboard/clipboard_aurax11.cc
View file @ 24f3d915
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
#include "ui/base/clipboard/clipboard.h" #include "ui/base/clipboard/clipboard_aurax11.h"
#include <X11/extensions/Xfixes.h> #include <X11/extensions/Xfixes.h>
#include <X11/Xatom.h> #include <X11/Xatom.h>
...@@ -222,11 +222,11 @@ bool Clipboard::FormatType::Equals(const FormatType& other) const { ...@@ -222,11 +222,11 @@ bool Clipboard::FormatType::Equals(const FormatType& other) const {
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Clipboard::AuraX11Details // ClipboardAuraX11::AuraX11Details
// Private implementation of our X11 integration. Keeps X11 headers out of the // Private implementation of our X11 integration. Keeps X11 headers out of the
// majority of chrome, which break badly. // majority of chrome, which break badly.
class Clipboard::AuraX11Details : public PlatformEventDispatcher { class ClipboardAuraX11::AuraX11Details : public PlatformEventDispatcher {
public: public:
AuraX11Details(); AuraX11Details();
virtual ~AuraX11Details(); virtual ~AuraX11Details();
...@@ -315,18 +315,21 @@ class Clipboard::AuraX11Details : public PlatformEventDispatcher { ...@@ -315,18 +315,21 @@ class Clipboard::AuraX11Details : public PlatformEventDispatcher {
DISALLOW_COPY_AND_ASSIGN(AuraX11Details); DISALLOW_COPY_AND_ASSIGN(AuraX11Details);
}; };
Clipboard::AuraX11Details::AuraX11Details() ClipboardAuraX11::AuraX11Details::AuraX11Details()
: x_display_(gfx::GetXDisplay()), : x_display_(gfx::GetXDisplay()),
x_root_window_(DefaultRootWindow(x_display_)), x_root_window_(DefaultRootWindow(x_display_)),
x_window_(XCreateWindow( x_window_(XCreateWindow(x_display_,
x_display_, x_root_window_, x_root_window_,
-100, -100, 10, 10, // x, y, width, height -100,
0, // border width -100,
CopyFromParent, // depth 10,
InputOnly, 10, // x, y, width, height
CopyFromParent, // visual 0, // border width
0, CopyFromParent, // depth
NULL)), InputOnly,
CopyFromParent, // visual
0,
NULL)),
atom_cache_(x_display_, kAtomsToCache), atom_cache_(x_display_, kAtomsToCache),
selection_requestor_(x_display_, x_window_, this), selection_requestor_(x_display_, x_window_, this),
clipboard_owner_(x_display_, x_window_, atom_cache_.GetAtom(kClipboard)), clipboard_owner_(x_display_, x_window_, atom_cache_.GetAtom(kClipboard)),
...@@ -341,14 +344,14 @@ Clipboard::AuraX11Details::AuraX11Details() ...@@ -341,14 +344,14 @@ Clipboard::AuraX11Details::AuraX11Details()
PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this); PlatformEventSource::GetInstance()->AddPlatformEventDispatcher(this);
} }
Clipboard::AuraX11Details::~AuraX11Details() { ClipboardAuraX11::AuraX11Details::~AuraX11Details() {
if (PlatformEventSource::GetInstance()) if (PlatformEventSource::GetInstance())
PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this); PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
XDestroyWindow(x_display_, x_window_); XDestroyWindow(x_display_, x_window_);
} }
::Atom Clipboard::AuraX11Details::LookupSelectionForClipboardType( ::Atom ClipboardAuraX11::AuraX11Details::LookupSelectionForClipboardType(
ClipboardType type) const { ClipboardType type) const {
if (type == CLIPBOARD_TYPE_COPY_PASTE) if (type == CLIPBOARD_TYPE_COPY_PASTE)
return GetCopyPasteSelection(); return GetCopyPasteSelection();
...@@ -356,12 +359,12 @@ Clipboard::AuraX11Details::~AuraX11Details() { ...@@ -356,12 +359,12 @@ Clipboard::AuraX11Details::~AuraX11Details() {
return XA_PRIMARY; return XA_PRIMARY;
} }
::Atom Clipboard::AuraX11Details::GetCopyPasteSelection() const { ::Atom ClipboardAuraX11::AuraX11Details::GetCopyPasteSelection() const {
return atom_cache_.GetAtom(kClipboard); return atom_cache_.GetAtom(kClipboard);
} }
const SelectionFormatMap& Clipboard::AuraX11Details::LookupStorageForAtom( const SelectionFormatMap&
::Atom atom) { ClipboardAuraX11::AuraX11Details::LookupStorageForAtom(::Atom atom) {
if (atom == XA_PRIMARY) if (atom == XA_PRIMARY)
return primary_owner_.selection_format_map(); return primary_owner_.selection_format_map();
...@@ -369,27 +372,28 @@ const SelectionFormatMap& Clipboard::AuraX11Details::LookupStorageForAtom( ...@@ -369,27 +372,28 @@ const SelectionFormatMap& Clipboard::AuraX11Details::LookupStorageForAtom(
return clipboard_owner_.selection_format_map(); return clipboard_owner_.selection_format_map();
} }
void Clipboard::AuraX11Details::CreateNewClipboardData() { void ClipboardAuraX11::AuraX11Details::CreateNewClipboardData() {
clipboard_data_ = SelectionFormatMap(); clipboard_data_ = SelectionFormatMap();
} }
void Clipboard::AuraX11Details::InsertMapping( void ClipboardAuraX11::AuraX11Details::InsertMapping(
const std::string& key, const std::string& key,
const scoped_refptr<base::RefCountedMemory>& memory) { const scoped_refptr<base::RefCountedMemory>& memory) {
::Atom atom_key = atom_cache_.GetAtom(key.c_str()); ::Atom atom_key = atom_cache_.GetAtom(key.c_str());
clipboard_data_.Insert(atom_key, memory); clipboard_data_.Insert(atom_key, memory);
} }
void Clipboard::AuraX11Details::TakeOwnershipOfSelection(ClipboardType type) { void ClipboardAuraX11::AuraX11Details::TakeOwnershipOfSelection(
ClipboardType type) {
if (type == CLIPBOARD_TYPE_COPY_PASTE) if (type == CLIPBOARD_TYPE_COPY_PASTE)
return clipboard_owner_.TakeOwnershipOfSelection(clipboard_data_); return clipboard_owner_.TakeOwnershipOfSelection(clipboard_data_);
else else
return primary_owner_.TakeOwnershipOfSelection(clipboard_data_); return primary_owner_.TakeOwnershipOfSelection(clipboard_data_);
} }
SelectionData Clipboard::AuraX11Details::RequestAndWaitForTypes( SelectionData ClipboardAuraX11::AuraX11Details::RequestAndWaitForTypes(
ClipboardType type, ClipboardType type,
const std::vector< ::Atom>& types) { const std::vector<::Atom>& types) {
::Atom selection_name = LookupSelectionForClipboardType(type); ::Atom selection_name = LookupSelectionForClipboardType(type);
if (XGetSelectionOwner(x_display_, selection_name) == x_window_) { if (XGetSelectionOwner(x_display_, selection_name) == x_window_) {
// We can local fastpath instead of playing the nested message loop game // We can local fastpath instead of playing the nested message loop game
...@@ -415,7 +419,7 @@ SelectionData Clipboard::AuraX11Details::RequestAndWaitForTypes( ...@@ -415,7 +419,7 @@ SelectionData Clipboard::AuraX11Details::RequestAndWaitForTypes(
return SelectionData(); return SelectionData();
} }
TargetList Clipboard::AuraX11Details::WaitAndGetTargetsList( TargetList ClipboardAuraX11::AuraX11Details::WaitAndGetTargetsList(
ClipboardType type) { ClipboardType type) {
::Atom selection_name = LookupSelectionForClipboardType(type); ::Atom selection_name = LookupSelectionForClipboardType(type);
std::vector< ::Atom> out; std::vector< ::Atom> out;
...@@ -471,25 +475,25 @@ TargetList Clipboard::AuraX11Details::WaitAndGetTargetsList( ...@@ -471,25 +475,25 @@ TargetList Clipboard::AuraX11Details::WaitAndGetTargetsList(
return TargetList(out, &atom_cache_); return TargetList(out, &atom_cache_);
} }
std::vector< ::Atom> Clipboard::AuraX11Details::GetTextAtoms() const { std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetTextAtoms() const {
return GetTextAtomsFrom(&atom_cache_); return GetTextAtomsFrom(&atom_cache_);
} }
std::vector< ::Atom> Clipboard::AuraX11Details::GetAtomsForFormat( std::vector<::Atom> ClipboardAuraX11::AuraX11Details::GetAtomsForFormat(
const Clipboard::FormatType& format) { const Clipboard::FormatType& format) {
std::vector< ::Atom> atoms; std::vector< ::Atom> atoms;
atoms.push_back(atom_cache_.GetAtom(format.ToString().c_str())); atoms.push_back(atom_cache_.GetAtom(format.ToString().c_str()));
return atoms; return atoms;
} }
void Clipboard::AuraX11Details::Clear(ClipboardType type) { void ClipboardAuraX11::AuraX11Details::Clear(ClipboardType type) {
if (type == CLIPBOARD_TYPE_COPY_PASTE) if (type == CLIPBOARD_TYPE_COPY_PASTE)
clipboard_owner_.ClearSelectionOwner(); clipboard_owner_.ClearSelectionOwner();
else else
primary_owner_.ClearSelectionOwner(); primary_owner_.ClearSelectionOwner();
} }
void Clipboard::AuraX11Details::StoreCopyPasteDataAndWait() { void ClipboardAuraX11::AuraX11Details::StoreCopyPasteDataAndWait() {
::Atom selection = GetCopyPasteSelection(); ::Atom selection = GetCopyPasteSelection();
if (XGetSelectionOwner(x_display_, selection) != x_window_) if (XGetSelectionOwner(x_display_, selection) != x_window_)
return; return;
...@@ -512,7 +516,8 @@ void Clipboard::AuraX11Details::StoreCopyPasteDataAndWait() { ...@@ -512,7 +516,8 @@ void Clipboard::AuraX11Details::StoreCopyPasteDataAndWait() {
base::TimeTicks::Now() - start); base::TimeTicks::Now() - start);
} }
bool Clipboard::AuraX11Details::CanDispatchEvent(const PlatformEvent& event) { bool ClipboardAuraX11::AuraX11Details::CanDispatchEvent(
const PlatformEvent& event) {
if (event->xany.window == x_window_) if (event->xany.window == x_window_)
return true; return true;
...@@ -524,7 +529,8 @@ bool Clipboard::AuraX11Details::CanDispatchEvent(const PlatformEvent& event) { ...@@ -524,7 +529,8 @@ bool Clipboard::AuraX11Details::CanDispatchEvent(const PlatformEvent& event) {
return false; return false;
} }
uint32_t Clipboard::AuraX11Details::DispatchEvent(const PlatformEvent& xev) { uint32_t ClipboardAuraX11::AuraX11Details::DispatchEvent(
const PlatformEvent& xev) {
switch (xev->type) { switch (xev->type) {
case SelectionRequest: { case SelectionRequest: {
if (xev->xselectionrequest.selection == XA_PRIMARY) { if (xev->xselectionrequest.selection == XA_PRIMARY) {
...@@ -646,20 +652,25 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() { ...@@ -646,20 +652,25 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
} }
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Clipboard // Clipboard factory method.
Clipboard* Clipboard::Create() {
return new ClipboardAuraX11;
}
///////////////////////////////////////////////////////////////////////////////
// ClipboardAuraX11
Clipboard::Clipboard() ClipboardAuraX11::ClipboardAuraX11() : aurax11_details_(new AuraX11Details) {
: aurax11_details_(new AuraX11Details) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
} }
Clipboard::~Clipboard() { ClipboardAuraX11::~ClipboardAuraX11() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
aurax11_details_->StoreCopyPasteDataAndWait(); aurax11_details_->StoreCopyPasteDataAndWait();
} }
uint64 Clipboard::GetSequenceNumber(ClipboardType type) { uint64 ClipboardAuraX11::GetSequenceNumber(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
if (type == CLIPBOARD_TYPE_COPY_PASTE) if (type == CLIPBOARD_TYPE_COPY_PASTE)
return SelectionChangeObserver::GetInstance()->clipboard_sequence_number(); return SelectionChangeObserver::GetInstance()->clipboard_sequence_number();
...@@ -667,8 +678,8 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType type) { ...@@ -667,8 +678,8 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
return SelectionChangeObserver::GetInstance()->primary_sequence_number(); return SelectionChangeObserver::GetInstance()->primary_sequence_number();
} }
bool Clipboard::IsFormatAvailable(const FormatType& format, bool ClipboardAuraX11::IsFormatAvailable(const FormatType& format,
ClipboardType type) const { ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
...@@ -680,15 +691,15 @@ bool Clipboard::IsFormatAvailable(const FormatType& format, ...@@ -680,15 +691,15 @@ bool Clipboard::IsFormatAvailable(const FormatType& format,
return target_list.ContainsFormat(format); return target_list.ContainsFormat(format);
} }
void Clipboard::Clear(ClipboardType type) { void ClipboardAuraX11::Clear(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
aurax11_details_->Clear(type); aurax11_details_->Clear(type);
} }
void Clipboard::ReadAvailableTypes(ClipboardType type, void ClipboardAuraX11::ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const { bool* contains_filenames) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
if (!types || !contains_filenames) { if (!types || !contains_filenames) {
NOTREACHED(); NOTREACHED();
...@@ -715,7 +726,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -715,7 +726,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
ReadCustomDataTypes(data.GetData(), data.GetSize(), types); ReadCustomDataTypes(data.GetData(), data.GetSize(), types);
} }
void Clipboard::ReadText(ClipboardType type, base::string16* result) const { void ClipboardAuraX11::ReadText(ClipboardType type,
base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -726,7 +738,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const { ...@@ -726,7 +738,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
} }
} }
void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { void ClipboardAuraX11::ReadAsciiText(ClipboardType type,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -737,11 +750,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { ...@@ -737,11 +750,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
// TODO(estade): handle different charsets. // TODO(estade): handle different charsets.
// TODO(port): set *src_url. // TODO(port): set *src_url.
void Clipboard::ReadHTML(ClipboardType type, void ClipboardAuraX11::ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const { uint32* fragment_end) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
markup->clear(); markup->clear();
if (src_url) if (src_url)
...@@ -760,7 +773,7 @@ void Clipboard::ReadHTML(ClipboardType type, ...@@ -760,7 +773,7 @@ void Clipboard::ReadHTML(ClipboardType type,
} }
} }
void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { void ClipboardAuraX11::ReadRTF(ClipboardType type, std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -769,7 +782,7 @@ void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { ...@@ -769,7 +782,7 @@ void Clipboard::ReadRTF(ClipboardType type, std::string* result) const {
data.AssignTo(result); data.AssignTo(result);
} }
SkBitmap Clipboard::ReadImage(ClipboardType type) const { SkBitmap ClipboardAuraX11::ReadImage(ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -783,9 +796,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const { ...@@ -783,9 +796,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const {
return SkBitmap(); return SkBitmap();
} }
void Clipboard::ReadCustomData(ClipboardType clipboard_type, void ClipboardAuraX11::ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const { base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -795,13 +808,15 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type, ...@@ -795,13 +808,15 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type,
ReadCustomDataForType(data.GetData(), data.GetSize(), type, result); ReadCustomDataForType(data.GetData(), data.GetSize(), type, result);
} }
void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { void ClipboardAuraX11::ReadBookmark(base::string16* title,
std::string* url) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
// TODO(erg): This was left NOTIMPLEMENTED() in the gtk port too. // TODO(erg): This was left NOTIMPLEMENTED() in the gtk port too.
NOTIMPLEMENTED(); NOTIMPLEMENTED();
} }
void Clipboard::ReadData(const FormatType& format, std::string* result) const { void ClipboardAuraX11::ReadData(const FormatType& format,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
SelectionData data(aurax11_details_->RequestAndWaitForTypes( SelectionData data(aurax11_details_->RequestAndWaitForTypes(
...@@ -810,13 +825,14 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const { ...@@ -810,13 +825,14 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const {
data.AssignTo(result); data.AssignTo(result);
} }
void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { void ClipboardAuraX11::WriteObjects(ClipboardType type,
const ObjectMap& objects) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK(IsSupportedClipboardType(type)); DCHECK(IsSupportedClipboardType(type));
aurax11_details_->CreateNewClipboardData(); aurax11_details_->CreateNewClipboardData();
for (ObjectMap::const_iterator iter = objects.begin(); for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
iter != objects.end(); ++iter) { ++iter) {
DispatchObject(static_cast<ObjectType>(iter->first), iter->second); DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
} }
aurax11_details_->TakeOwnershipOfSelection(type); aurax11_details_->TakeOwnershipOfSelection(type);
...@@ -836,7 +852,7 @@ void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { ...@@ -836,7 +852,7 @@ void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
} }
} }
void Clipboard::WriteText(const char* text_data, size_t text_len) { void ClipboardAuraX11::WriteText(const char* text_data, size_t text_len) {
std::string str(text_data, text_len); std::string str(text_data, text_len);
scoped_refptr<base::RefCountedMemory> mem( scoped_refptr<base::RefCountedMemory> mem(
base::RefCountedString::TakeString(&str)); base::RefCountedString::TakeString(&str));
...@@ -847,10 +863,10 @@ void Clipboard::WriteText(const char* text_data, size_t text_len) { ...@@ -847,10 +863,10 @@ void Clipboard::WriteText(const char* text_data, size_t text_len) {
aurax11_details_->InsertMapping(kUtf8String, mem); aurax11_details_->InsertMapping(kUtf8String, mem);
} }
void Clipboard::WriteHTML(const char* markup_data, void ClipboardAuraX11::WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
// TODO(estade): We need to expand relative links with |url_data|. // TODO(estade): We need to expand relative links with |url_data|.
static const char* html_prefix = "<meta http-equiv=\"content-type\" " static const char* html_prefix = "<meta http-equiv=\"content-type\" "
"content=\"text/html; charset=utf-8\">"; "content=\"text/html; charset=utf-8\">";
...@@ -864,14 +880,14 @@ void Clipboard::WriteHTML(const char* markup_data, ...@@ -864,14 +880,14 @@ void Clipboard::WriteHTML(const char* markup_data,
aurax11_details_->InsertMapping(kMimeTypeHTML, mem); aurax11_details_->InsertMapping(kMimeTypeHTML, mem);
} }
void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) { void ClipboardAuraX11::WriteRTF(const char* rtf_data, size_t data_len) {
WriteData(GetRtfFormatType(), rtf_data, data_len); WriteData(GetRtfFormatType(), rtf_data, data_len);
} }
void Clipboard::WriteBookmark(const char* title_data, void ClipboardAuraX11::WriteBookmark(const char* title_data,
size_t title_len, size_t title_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
// Write as a mozilla url (UTF16: URL, newline, title). // Write as a mozilla url (UTF16: URL, newline, title).
base::string16 url = base::UTF8ToUTF16(std::string(url_data, url_len) + "\n"); base::string16 url = base::UTF8ToUTF16(std::string(url_data, url_len) + "\n");
base::string16 title = base::UTF8ToUTF16(std::string(title_data, title_len)); base::string16 title = base::UTF8ToUTF16(std::string(title_data, title_len));
...@@ -887,7 +903,7 @@ void Clipboard::WriteBookmark(const char* title_data, ...@@ -887,7 +903,7 @@ void Clipboard::WriteBookmark(const char* title_data,
// Write an extra flavor that signifies WebKit was the last to modify the // Write an extra flavor that signifies WebKit was the last to modify the
// pasteboard. This flavor has no data. // pasteboard. This flavor has no data.
void Clipboard::WriteWebSmartPaste() { void ClipboardAuraX11::WriteWebSmartPaste() {
std::string empty; std::string empty;
aurax11_details_->InsertMapping( aurax11_details_->InsertMapping(
kMimeTypeWebkitSmartPaste, kMimeTypeWebkitSmartPaste,
...@@ -895,7 +911,7 @@ void Clipboard::WriteWebSmartPaste() { ...@@ -895,7 +911,7 @@ void Clipboard::WriteWebSmartPaste() {
base::RefCountedString::TakeString(&empty))); base::RefCountedString::TakeString(&empty)));
} }
void Clipboard::WriteBitmap(const SkBitmap& bitmap) { void ClipboardAuraX11::WriteBitmap(const SkBitmap& bitmap) {
// Encode the bitmap as a PNG for transport. // Encode the bitmap as a PNG for transport.
std::vector<unsigned char> output; std::vector<unsigned char> output;
if (gfx::PNGCodec::FastEncodeBGRASkBitmap(bitmap, false, &output)) { if (gfx::PNGCodec::FastEncodeBGRASkBitmap(bitmap, false, &output)) {
...@@ -905,9 +921,9 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) { ...@@ -905,9 +921,9 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
} }
} }
void Clipboard::WriteData(const FormatType& format, void ClipboardAuraX11::WriteData(const FormatType& format,
const char* data_data, const char* data_data,
size_t data_len) { size_t data_len) {
// We assume that certain mapping types are only written by trusted code. // We assume that certain mapping types are only written by trusted code.
// Therefore we must upkeep their integrity. // Therefore we must upkeep their integrity.
if (format.Equals(GetBitmapFormatType())) if (format.Equals(GetBitmapFormatType()))
......
ui/base/clipboard/clipboard_aurax11.h 0 → 100644
View file @ 24f3d915
// Copyright 2014 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_AURAX11_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_AURAX11_H_
#include "ui/base/clipboard/clipboard.h"
#include "base/memory/scoped_ptr.h"
namespace ui {
class ClipboardAuraX11 : public Clipboard {
private:
friend class Clipboard;
ClipboardAuraX11();
~ClipboardAuraX11() override;
// Clipboard overrides:
uint64 GetSequenceNumber(ClipboardType type) override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) const override;
void ReadText(ClipboardType type, base::string16* result) const override;
void ReadAsciiText(ClipboardType type, std::string* result) const override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
uint32* fragment_start,
uint32* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type,
base::string16* result) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
void ReadData(const FormatType& format, std::string* result) const override;
void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
void WriteText(const char* text_data, size_t text_len) override;
void WriteHTML(const char* markup_data,
size_t markup_len,
const char* url_data,
size_t url_len) override;
void WriteRTF(const char* rtf_data, size_t data_len) override;
void WriteBookmark(const char* title_data,
size_t title_len,
const char* url_data,
size_t url_len) override;
void WriteWebSmartPaste() override;
void WriteBitmap(const SkBitmap& bitmap) override;
void WriteData(const FormatType& format,
const char* data_data,
size_t data_len) override;
// TODO(dcheng): Is this still needed now that each platform clipboard has its
// own class derived from Clipboard?
class AuraX11Details;
scoped_ptr<AuraX11Details> aurax11_details_;
DISALLOW_COPY_AND_ASSIGN(ClipboardAuraX11);
};
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_AURAX11_H_
ui/base/clipboard/clipboard_mac.h 0 → 100644
View file @ 24f3d915
// Copyright 2014 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_MAC_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_MAC_H_
#include "ui/base/clipboard/clipboard.h"
namespace ui {
class ClipboardMac : public Clipboard {
private:
friend class Clipboard;
ClipboardMac();
~ClipboardMac() override;
// Clipboard overrides:
uint64 GetSequenceNumber(ClipboardType type) override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) const override;
void ReadText(ClipboardType type, base::string16* result) const override;
void ReadAsciiText(ClipboardType type, std::string* result) const override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
uint32* fragment_start,
uint32* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type,
base::string16* result) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
void ReadData(const FormatType& format, std::string* result) const override;
void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
void WriteText(const char* text_data, size_t text_len) override;
void WriteHTML(const char* markup_data,
size_t markup_len,
const char* url_data,
size_t url_len) override;
void WriteRTF(const char* rtf_data, size_t data_len) override;
void WriteBookmark(const char* title_data,
size_t title_len,
const char* url_data,
size_t url_len) override;
void WriteWebSmartPaste() override;
void WriteBitmap(const SkBitmap& bitmap) override;
void WriteData(const FormatType& format,
const char* data_data,
size_t data_len) override;
DISALLOW_COPY_AND_ASSIGN(ClipboardMac);
};
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_MAC_H_
ui/base/clipboard/clipboard_mac.mm
View file @ 24f3d915
...@@ -2,7 +2,7 @@ ...@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
#include "ui/base/clipboard/clipboard.h" #include "ui/base/clipboard/clipboard_mac.h"
#import <Cocoa/Cocoa.h> #import <Cocoa/Cocoa.h>
...@@ -165,16 +165,22 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() { ...@@ -165,16 +165,22 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
return type; return type;
} }
// Clipboard implementation. // Clipboard factory method.
Clipboard::Clipboard() { // static
Clipboard* Clipboard::Create() {
return new ClipboardMac;
}
// ClipboardMac implementation.
ClipboardMac::ClipboardMac() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
} }
Clipboard::~Clipboard() { ClipboardMac::~ClipboardMac() {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
} }
uint64 Clipboard::GetSequenceNumber(ClipboardType type) { uint64 ClipboardMac::GetSequenceNumber(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -182,8 +188,8 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType type) { ...@@ -182,8 +188,8 @@ uint64 Clipboard::GetSequenceNumber(ClipboardType type) {
return [pb changeCount]; return [pb changeCount];
} }
bool Clipboard::IsFormatAvailable(const FormatType& format, bool ClipboardMac::IsFormatAvailable(const FormatType& format,
ClipboardType type) const { ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -199,7 +205,7 @@ bool Clipboard::IsFormatAvailable(const FormatType& format, ...@@ -199,7 +205,7 @@ bool Clipboard::IsFormatAvailable(const FormatType& format,
return [types containsObject:format.ToNSString()]; return [types containsObject:format.ToNSString()];
} }
void Clipboard::Clear(ClipboardType type) { void ClipboardMac::Clear(ClipboardType type) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -207,9 +213,9 @@ void Clipboard::Clear(ClipboardType type) { ...@@ -207,9 +213,9 @@ void Clipboard::Clear(ClipboardType type) {
[pb declareTypes:[NSArray array] owner:nil]; [pb declareTypes:[NSArray array] owner:nil];
} }
void Clipboard::ReadAvailableTypes(ClipboardType type, void ClipboardMac::ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const { bool* contains_filenames) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
types->clear(); types->clear();
if (IsFormatAvailable(Clipboard::GetPlainTextFormatType(), type)) if (IsFormatAvailable(Clipboard::GetPlainTextFormatType(), type))
...@@ -230,7 +236,7 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -230,7 +236,7 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
} }
} }
void Clipboard::ReadText(ClipboardType type, base::string16* result) const { void ClipboardMac::ReadText(ClipboardType type, base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
...@@ -239,7 +245,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const { ...@@ -239,7 +245,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
*result = base::SysNSStringToUTF16(contents); *result = base::SysNSStringToUTF16(contents);
} }
void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { void ClipboardMac::ReadAsciiText(ClipboardType type,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
...@@ -251,11 +258,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { ...@@ -251,11 +258,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
result->assign([contents UTF8String]); result->assign([contents UTF8String]);
} }
void Clipboard::ReadHTML(ClipboardType type, void ClipboardMac::ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const { uint32* fragment_end) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -282,14 +289,14 @@ void Clipboard::ReadHTML(ClipboardType type, ...@@ -282,14 +289,14 @@ void Clipboard::ReadHTML(ClipboardType type,
*fragment_end = static_cast<uint32>(markup->length()); *fragment_end = static_cast<uint32>(markup->length());
} }
void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { void ClipboardMac::ReadRTF(ClipboardType type, std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
return ReadData(GetRtfFormatType(), result); return ReadData(GetRtfFormatType(), result);
} }
SkBitmap Clipboard::ReadImage(ClipboardType type) const { SkBitmap ClipboardMac::ReadImage(ClipboardType type) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -307,9 +314,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const { ...@@ -307,9 +314,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const {
return bitmap; return bitmap;
} }
void Clipboard::ReadCustomData(ClipboardType clipboard_type, void ClipboardMac::ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const { base::string16* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE);
...@@ -321,7 +328,7 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type, ...@@ -321,7 +328,7 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type,
} }
} }
void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { void ClipboardMac::ReadBookmark(base::string16* title, std::string* url) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
...@@ -339,7 +346,8 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { ...@@ -339,7 +346,8 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
} }
} }
void Clipboard::ReadData(const FormatType& format, std::string* result) const { void ClipboardMac::ReadData(const FormatType& format,
std::string* result) const {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
NSData* data = [pb dataForType:format.ToNSString()]; NSData* data = [pb dataForType:format.ToNSString()];
...@@ -347,35 +355,35 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const { ...@@ -347,35 +355,35 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const {
result->assign(static_cast<const char*>([data bytes]), [data length]); result->assign(static_cast<const char*>([data bytes]), [data length]);
} }
void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { void ClipboardMac::WriteObjects(ClipboardType type, const ObjectMap& objects) {
DCHECK(CalledOnValidThread()); DCHECK(CalledOnValidThread());
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
[pb declareTypes:[NSArray array] owner:nil]; [pb declareTypes:[NSArray array] owner:nil];
for (ObjectMap::const_iterator iter = objects.begin(); for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
iter != objects.end(); ++iter) { ++iter) {
DispatchObject(static_cast<ObjectType>(iter->first), iter->second); DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
} }
} }
void Clipboard::WriteText(const char* text_data, size_t text_len) { void ClipboardMac::WriteText(const char* text_data, size_t text_len) {
std::string text_str(text_data, text_len); std::string text_str(text_data, text_len);
NSString *text = base::SysUTF8ToNSString(text_str); NSString* text = base::SysUTF8ToNSString(text_str);
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
[pb addTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil]; [pb addTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil];
[pb setString:text forType:NSStringPboardType]; [pb setString:text forType:NSStringPboardType];
} }
void Clipboard::WriteHTML(const char* markup_data, void ClipboardMac::WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
// We need to mark it as utf-8. (see crbug.com/11957) // We need to mark it as utf-8. (see crbug.com/11957)
std::string html_fragment_str("<meta charset='utf-8'>"); std::string html_fragment_str("<meta charset='utf-8'>");
html_fragment_str.append(markup_data, markup_len); html_fragment_str.append(markup_data, markup_len);
NSString *html_fragment = base::SysUTF8ToNSString(html_fragment_str); NSString* html_fragment = base::SysUTF8ToNSString(html_fragment_str);
// TODO(avi): url_data? // TODO(avi): url_data?
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
...@@ -383,18 +391,18 @@ void Clipboard::WriteHTML(const char* markup_data, ...@@ -383,18 +391,18 @@ void Clipboard::WriteHTML(const char* markup_data,
[pb setString:html_fragment forType:NSHTMLPboardType]; [pb setString:html_fragment forType:NSHTMLPboardType];
} }
void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) { void ClipboardMac::WriteRTF(const char* rtf_data, size_t data_len) {
WriteData(GetRtfFormatType(), rtf_data, data_len); WriteData(GetRtfFormatType(), rtf_data, data_len);
} }
void Clipboard::WriteBookmark(const char* title_data, void ClipboardMac::WriteBookmark(const char* title_data,
size_t title_len, size_t title_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
std::string title_str(title_data, title_len); std::string title_str(title_data, title_len);
NSString *title = base::SysUTF8ToNSString(title_str); NSString* title = base::SysUTF8ToNSString(title_str);
std::string url_str(url_data, url_len); std::string url_str(url_data, url_len);
NSString *url = base::SysUTF8ToNSString(url_str); NSString* url = base::SysUTF8ToNSString(url_str);
// TODO(playmobil): In the Windows version of this function, an HTML // TODO(playmobil): In the Windows version of this function, an HTML
// representation of the bookmark is also added to the clipboard, to support // representation of the bookmark is also added to the clipboard, to support
...@@ -404,31 +412,29 @@ void Clipboard::WriteBookmark(const char* title_data, ...@@ -404,31 +412,29 @@ void Clipboard::WriteBookmark(const char* title_data,
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
// passing UTIs into the pasteboard methods is valid >= 10.5 // passing UTIs into the pasteboard methods is valid >= 10.5
[pb addTypes:[NSArray arrayWithObjects:NSURLPboardType, [pb addTypes:[NSArray arrayWithObjects:NSURLPboardType, kUTTypeURLName, nil]
kUTTypeURLName,
nil]
owner:nil]; owner:nil];
[nsurl writeToPasteboard:pb]; [nsurl writeToPasteboard:pb];
[pb setString:title forType:kUTTypeURLName]; [pb setString:title forType:kUTTypeURLName];
} }
void Clipboard::WriteBitmap(const SkBitmap& bitmap) { void ClipboardMac::WriteBitmap(const SkBitmap& bitmap) {
NSImage* image = gfx::SkBitmapToNSImageWithColorSpace( NSImage* image = gfx::SkBitmapToNSImageWithColorSpace(
bitmap, base::mac::GetSystemColorSpace()); bitmap, base::mac::GetSystemColorSpace());
// An API to ask the NSImage to write itself to the clipboard comes in 10.6 :( // An API to ask the NSImage to write itself to the clipboard comes in 10.6 :(
// For now, spit out the image as a TIFF. // For now, spit out the image as a TIFF.
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
[pb addTypes:[NSArray arrayWithObject:NSTIFFPboardType] owner:nil]; [pb addTypes:[NSArray arrayWithObject:NSTIFFPboardType] owner:nil];
NSData *tiff_data = [image TIFFRepresentation]; NSData* tiff_data = [image TIFFRepresentation];
LOG_IF(ERROR, tiff_data == NULL) << "Failed to allocate image for clipboard"; LOG_IF(ERROR, tiff_data == NULL) << "Failed to allocate image for clipboard";
if (tiff_data) { if (tiff_data) {
[pb setData:tiff_data forType:NSTIFFPboardType]; [pb setData:tiff_data forType:NSTIFFPboardType];
} }
} }
void Clipboard::WriteData(const FormatType& format, void ClipboardMac::WriteData(const FormatType& format,
const char* data_data, const char* data_data,
size_t data_len) { size_t data_len) {
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
[pb addTypes:[NSArray arrayWithObject:format.ToNSString()] owner:nil]; [pb addTypes:[NSArray arrayWithObject:format.ToNSString()] owner:nil];
[pb setData:[NSData dataWithBytes:data_data length:data_len] [pb setData:[NSData dataWithBytes:data_data length:data_len]
...@@ -437,7 +443,7 @@ void Clipboard::WriteData(const FormatType& format, ...@@ -437,7 +443,7 @@ void Clipboard::WriteData(const FormatType& format,
// Write an extra flavor that signifies WebKit was the last to modify the // Write an extra flavor that signifies WebKit was the last to modify the
// pasteboard. This flavor has no data. // pasteboard. This flavor has no data.
void Clipboard::WriteWebSmartPaste() { void ClipboardMac::WriteWebSmartPaste() {
NSPasteboard* pb = GetPasteboard(); NSPasteboard* pb = GetPasteboard();
NSString* format = GetWebKitSmartPasteFormatType().ToNSString(); NSString* format = GetWebKitSmartPasteFormatType().ToNSString();
[pb addTypes:[NSArray arrayWithObject:format] owner:nil]; [pb addTypes:[NSArray arrayWithObject:format] owner:nil];
......
ui/base/clipboard/clipboard_win.cc
View file @ 24f3d915
...@@ -5,7 +5,7 @@ ...@@ -5,7 +5,7 @@
// Many of these functions are based on those found in // Many of these functions are based on those found in
// webkit/port/platform/PasteboardWin.cpp // webkit/port/platform/PasteboardWin.cpp
#include "ui/base/clipboard/clipboard.h" #include "ui/base/clipboard/clipboard_win.h"
#include <shellapi.h> #include <shellapi.h>
#include <shlobj.h> #include <shlobj.h>
...@@ -159,6 +159,31 @@ void MakeBitmapOpaque(const SkBitmap& bitmap) { ...@@ -159,6 +159,31 @@ void MakeBitmapOpaque(const SkBitmap& bitmap) {
} }
} }
void ParseBookmarkClipboardFormat(const base::string16& bookmark,
base::string16* title,
std::string* url) {
const base::string16 kDelim = base::ASCIIToUTF16("\r\n");
const size_t title_end = bookmark.find_first_of(kDelim);
if (title)
title->assign(bookmark.substr(0, title_end));
if (url) {
const size_t url_start = bookmark.find_first_not_of(kDelim, title_end);
if (url_start != base::string16::npos) {
*url =
base::UTF16ToUTF8(bookmark.substr(url_start, base::string16::npos));
}
}
}
void FreeData(unsigned int format, HANDLE data) {
if (format == CF_BITMAP)
::DeleteObject(static_cast<HBITMAP>(data));
else
::GlobalFree(data);
}
} // namespace } // namespace
// Clipboard::FormatType implementation. // Clipboard::FormatType implementation.
...@@ -201,11 +226,11 @@ Clipboard::FormatType Clipboard::FormatType::Deserialize( ...@@ -201,11 +226,11 @@ Clipboard::FormatType Clipboard::FormatType::Deserialize(
} }
bool Clipboard::FormatType::operator<(const FormatType& other) const { bool Clipboard::FormatType::operator<(const FormatType& other) const {
return ToUINT() < other.ToUINT(); return data_.cfFormat < other.data_.cfFormat;
} }
bool Clipboard::FormatType::Equals(const FormatType& other) const { bool Clipboard::FormatType::Equals(const FormatType& other) const {
return ToUINT() == other.ToUINT(); return data_.cfFormat == other.data_.cfFormat;
} }
// Various predefined FormatTypes. // Various predefined FormatTypes.
...@@ -348,27 +373,33 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() { ...@@ -348,27 +373,33 @@ const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
return type; return type;
} }
// Clipboard implementation. // Clipboard factory method.
Clipboard::Clipboard() { // static
Clipboard* Clipboard::Create() {
return new ClipboardWin;
}
// ClipboardWin implementation.
ClipboardWin::ClipboardWin() {
if (base::MessageLoopForUI::IsCurrent()) if (base::MessageLoopForUI::IsCurrent())
clipboard_owner_.reset(new base::win::MessageWindow()); clipboard_owner_.reset(new base::win::MessageWindow());
} }
Clipboard::~Clipboard() { ClipboardWin::~ClipboardWin() {
} }
uint64 Clipboard::GetSequenceNumber(ClipboardType type) { uint64 ClipboardWin::GetSequenceNumber(ClipboardType type) {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
return ::GetClipboardSequenceNumber(); return ::GetClipboardSequenceNumber();
} }
bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format, bool ClipboardWin::IsFormatAvailable(const Clipboard::FormatType& format,
ClipboardType type) const { ClipboardType type) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
return ::IsClipboardFormatAvailable(format.ToUINT()) != FALSE; return ::IsClipboardFormatAvailable(format.ToFormatEtc().cfFormat) != FALSE;
} }
void Clipboard::Clear(ClipboardType type) { void ClipboardWin::Clear(ClipboardType type) {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
ScopedClipboard clipboard; ScopedClipboard clipboard;
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
...@@ -377,20 +408,21 @@ void Clipboard::Clear(ClipboardType type) { ...@@ -377,20 +408,21 @@ void Clipboard::Clear(ClipboardType type) {
::EmptyClipboard(); ::EmptyClipboard();
} }
void Clipboard::ReadAvailableTypes(ClipboardType type, void ClipboardWin::ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types, std::vector<base::string16>* types,
bool* contains_filenames) const { bool* contains_filenames) const {
if (!types || !contains_filenames) { if (!types || !contains_filenames) {
NOTREACHED(); NOTREACHED();
return; return;
} }
types->clear(); types->clear();
if (::IsClipboardFormatAvailable(GetPlainTextFormatType().ToUINT())) if (::IsClipboardFormatAvailable(
GetPlainTextFormatType().ToFormatEtc().cfFormat))
types->push_back(base::UTF8ToUTF16(kMimeTypeText)); types->push_back(base::UTF8ToUTF16(kMimeTypeText));
if (::IsClipboardFormatAvailable(GetHtmlFormatType().ToUINT())) if (::IsClipboardFormatAvailable(GetHtmlFormatType().ToFormatEtc().cfFormat))
types->push_back(base::UTF8ToUTF16(kMimeTypeHTML)); types->push_back(base::UTF8ToUTF16(kMimeTypeHTML));
if (::IsClipboardFormatAvailable(GetRtfFormatType().ToUINT())) if (::IsClipboardFormatAvailable(GetRtfFormatType().ToFormatEtc().cfFormat))
types->push_back(base::UTF8ToUTF16(kMimeTypeRTF)); types->push_back(base::UTF8ToUTF16(kMimeTypeRTF));
if (::IsClipboardFormatAvailable(CF_DIB)) if (::IsClipboardFormatAvailable(CF_DIB))
types->push_back(base::UTF8ToUTF16(kMimeTypePNG)); types->push_back(base::UTF8ToUTF16(kMimeTypePNG));
...@@ -401,7 +433,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -401,7 +433,8 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
return; return;
HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT()); HANDLE hdata =
::GetClipboardData(GetWebCustomDataFormatType().ToFormatEtc().cfFormat);
if (!hdata) if (!hdata)
return; return;
...@@ -409,7 +442,7 @@ void Clipboard::ReadAvailableTypes(ClipboardType type, ...@@ -409,7 +442,7 @@ void Clipboard::ReadAvailableTypes(ClipboardType type,
::GlobalUnlock(hdata); ::GlobalUnlock(hdata);
} }
void Clipboard::ReadText(ClipboardType type, base::string16* result) const { void ClipboardWin::ReadText(ClipboardType type, base::string16* result) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
if (!result) { if (!result) {
NOTREACHED(); NOTREACHED();
...@@ -431,7 +464,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const { ...@@ -431,7 +464,8 @@ void Clipboard::ReadText(ClipboardType type, base::string16* result) const {
::GlobalUnlock(data); ::GlobalUnlock(data);
} }
void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { void ClipboardWin::ReadAsciiText(ClipboardType type,
std::string* result) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
if (!result) { if (!result) {
NOTREACHED(); NOTREACHED();
...@@ -453,11 +487,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const { ...@@ -453,11 +487,11 @@ void Clipboard::ReadAsciiText(ClipboardType type, std::string* result) const {
::GlobalUnlock(data); ::GlobalUnlock(data);
} }
void Clipboard::ReadHTML(ClipboardType type, void ClipboardWin::ReadHTML(ClipboardType type,
base::string16* markup, base::string16* markup,
std::string* src_url, std::string* src_url,
uint32* fragment_start, uint32* fragment_start,
uint32* fragment_end) const { uint32* fragment_end) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
markup->clear(); markup->clear();
...@@ -473,7 +507,7 @@ void Clipboard::ReadHTML(ClipboardType type, ...@@ -473,7 +507,7 @@ void Clipboard::ReadHTML(ClipboardType type,
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
return; return;
HANDLE data = ::GetClipboardData(GetHtmlFormatType().ToUINT()); HANDLE data = ::GetClipboardData(GetHtmlFormatType().ToFormatEtc().cfFormat);
if (!data) if (!data)
return; return;
...@@ -505,13 +539,13 @@ void Clipboard::ReadHTML(ClipboardType type, ...@@ -505,13 +539,13 @@ void Clipboard::ReadHTML(ClipboardType type,
*fragment_end = base::checked_cast<uint32>(offsets[1]); *fragment_end = base::checked_cast<uint32>(offsets[1]);
} }
void Clipboard::ReadRTF(ClipboardType type, std::string* result) const { void ClipboardWin::ReadRTF(ClipboardType type, std::string* result) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
ReadData(GetRtfFormatType(), result); ReadData(GetRtfFormatType(), result);
} }
SkBitmap Clipboard::ReadImage(ClipboardType type) const { SkBitmap ClipboardWin::ReadImage(ClipboardType type) const {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
// Acquire the clipboard. // Acquire the clipboard.
...@@ -581,9 +615,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const { ...@@ -581,9 +615,9 @@ SkBitmap Clipboard::ReadImage(ClipboardType type) const {
return canvas.ExtractImageRep().sk_bitmap(); return canvas.ExtractImageRep().sk_bitmap();
} }
void Clipboard::ReadCustomData(ClipboardType clipboard_type, void ClipboardWin::ReadCustomData(ClipboardType clipboard_type,
const base::string16& type, const base::string16& type,
base::string16* result) const { base::string16* result) const {
DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(clipboard_type, CLIPBOARD_TYPE_COPY_PASTE);
// Acquire the clipboard. // Acquire the clipboard.
...@@ -591,7 +625,8 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type, ...@@ -591,7 +625,8 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type,
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
return; return;
HANDLE hdata = ::GetClipboardData(GetWebCustomDataFormatType().ToUINT()); HANDLE hdata =
::GetClipboardData(GetWebCustomDataFormatType().ToFormatEtc().cfFormat);
if (!hdata) if (!hdata)
return; return;
...@@ -599,7 +634,7 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type, ...@@ -599,7 +634,7 @@ void Clipboard::ReadCustomData(ClipboardType clipboard_type,
::GlobalUnlock(hdata); ::GlobalUnlock(hdata);
} }
void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { void ClipboardWin::ReadBookmark(base::string16* title, std::string* url) const {
if (title) if (title)
title->clear(); title->clear();
...@@ -611,7 +646,7 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { ...@@ -611,7 +646,7 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
return; return;
HANDLE data = ::GetClipboardData(GetUrlWFormatType().ToUINT()); HANDLE data = ::GetClipboardData(GetUrlWFormatType().ToFormatEtc().cfFormat);
if (!data) if (!data)
return; return;
...@@ -621,7 +656,8 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const { ...@@ -621,7 +656,8 @@ void Clipboard::ReadBookmark(base::string16* title, std::string* url) const {
ParseBookmarkClipboardFormat(bookmark, title, url); ParseBookmarkClipboardFormat(bookmark, title, url);
} }
void Clipboard::ReadData(const FormatType& format, std::string* result) const { void ClipboardWin::ReadData(const FormatType& format,
std::string* result) const {
if (!result) { if (!result) {
NOTREACHED(); NOTREACHED();
return; return;
...@@ -631,7 +667,7 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const { ...@@ -631,7 +667,7 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const {
if (!clipboard.Acquire(GetClipboardWindow())) if (!clipboard.Acquire(GetClipboardWindow()))
return; return;
HANDLE data = ::GetClipboardData(format.ToUINT()); HANDLE data = ::GetClipboardData(format.ToFormatEtc().cfFormat);
if (!data) if (!data)
return; return;
...@@ -640,26 +676,7 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const { ...@@ -640,26 +676,7 @@ void Clipboard::ReadData(const FormatType& format, std::string* result) const {
::GlobalUnlock(data); ::GlobalUnlock(data);
} }
// static void ClipboardWin::WriteObjects(ClipboardType type, const ObjectMap& objects) {
void Clipboard::ParseBookmarkClipboardFormat(const base::string16& bookmark,
base::string16* title,
std::string* url) {
const base::string16 kDelim = base::ASCIIToUTF16("\r\n");
const size_t title_end = bookmark.find_first_of(kDelim);
if (title)
title->assign(bookmark.substr(0, title_end));
if (url) {
const size_t url_start = bookmark.find_first_not_of(kDelim, title_end);
if (url_start != base::string16::npos) {
*url = base::UTF16ToUTF8(
bookmark.substr(url_start, base::string16::npos));
}
}
}
void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE); DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
ScopedClipboard clipboard; ScopedClipboard clipboard;
...@@ -668,13 +685,13 @@ void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) { ...@@ -668,13 +685,13 @@ void Clipboard::WriteObjects(ClipboardType type, const ObjectMap& objects) {
::EmptyClipboard(); ::EmptyClipboard();
for (ObjectMap::const_iterator iter = objects.begin(); for (ObjectMap::const_iterator iter = objects.begin(); iter != objects.end();
iter != objects.end(); ++iter) { ++iter) {
DispatchObject(static_cast<ObjectType>(iter->first), iter->second); DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
} }
} }
void Clipboard::WriteText(const char* text_data, size_t text_len) { void ClipboardWin::WriteText(const char* text_data, size_t text_len) {
base::string16 text; base::string16 text;
base::UTF8ToUTF16(text_data, text_len, &text); base::UTF8ToUTF16(text_data, text_len, &text);
HGLOBAL glob = CreateGlobalData(text); HGLOBAL glob = CreateGlobalData(text);
...@@ -682,10 +699,10 @@ void Clipboard::WriteText(const char* text_data, size_t text_len) { ...@@ -682,10 +699,10 @@ void Clipboard::WriteText(const char* text_data, size_t text_len) {
WriteToClipboard(CF_UNICODETEXT, glob); WriteToClipboard(CF_UNICODETEXT, glob);
} }
void Clipboard::WriteHTML(const char* markup_data, void ClipboardWin::WriteHTML(const char* markup_data,
size_t markup_len, size_t markup_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
std::string markup(markup_data, markup_len); std::string markup(markup_data, markup_len);
std::string url; std::string url;
...@@ -695,17 +712,17 @@ void Clipboard::WriteHTML(const char* markup_data, ...@@ -695,17 +712,17 @@ void Clipboard::WriteHTML(const char* markup_data,
std::string html_fragment = ClipboardUtil::HtmlToCFHtml(markup, url); std::string html_fragment = ClipboardUtil::HtmlToCFHtml(markup, url);
HGLOBAL glob = CreateGlobalData(html_fragment); HGLOBAL glob = CreateGlobalData(html_fragment);
WriteToClipboard(Clipboard::GetHtmlFormatType().ToUINT(), glob); WriteToClipboard(Clipboard::GetHtmlFormatType().ToFormatEtc().cfFormat, glob);
} }
void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) { void ClipboardWin::WriteRTF(const char* rtf_data, size_t data_len) {
WriteData(GetRtfFormatType(), rtf_data, data_len); WriteData(GetRtfFormatType(), rtf_data, data_len);
} }
void Clipboard::WriteBookmark(const char* title_data, void ClipboardWin::WriteBookmark(const char* title_data,
size_t title_len, size_t title_len,
const char* url_data, const char* url_data,
size_t url_len) { size_t url_len) {
std::string bookmark(title_data, title_len); std::string bookmark(title_data, title_len);
bookmark.append(1, L'\n'); bookmark.append(1, L'\n');
bookmark.append(url_data, url_len); bookmark.append(url_data, url_len);
...@@ -713,15 +730,16 @@ void Clipboard::WriteBookmark(const char* title_data, ...@@ -713,15 +730,16 @@ void Clipboard::WriteBookmark(const char* title_data,
base::string16 wide_bookmark = base::UTF8ToWide(bookmark); base::string16 wide_bookmark = base::UTF8ToWide(bookmark);
HGLOBAL glob = CreateGlobalData(wide_bookmark); HGLOBAL glob = CreateGlobalData(wide_bookmark);
WriteToClipboard(GetUrlWFormatType().ToUINT(), glob); WriteToClipboard(GetUrlWFormatType().ToFormatEtc().cfFormat, glob);
} }
void Clipboard::WriteWebSmartPaste() { void ClipboardWin::WriteWebSmartPaste() {
DCHECK(clipboard_owner_->hwnd() != NULL); DCHECK(clipboard_owner_->hwnd() != NULL);
::SetClipboardData(GetWebKitSmartPasteFormatType().ToUINT(), NULL); ::SetClipboardData(GetWebKitSmartPasteFormatType().ToFormatEtc().cfFormat,
NULL);
} }
void Clipboard::WriteBitmap(const SkBitmap& bitmap) { void ClipboardWin::WriteBitmap(const SkBitmap& bitmap) {
HDC dc = ::GetDC(NULL); HDC dc = ::GetDC(NULL);
// This doesn't actually cost us a memcpy when the bitmap comes from the // This doesn't actually cost us a memcpy when the bitmap comes from the
...@@ -740,7 +758,7 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) { ...@@ -740,7 +758,7 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
// ::CreateDIBSection allocates memory for us to copy our bitmap into. // ::CreateDIBSection allocates memory for us to copy our bitmap into.
// Unfortunately, we can't write the created bitmap to the clipboard, // Unfortunately, we can't write the created bitmap to the clipboard,
// (see http://msdn2.microsoft.com/en-us/library/ms532292.aspx) // (see http://msdn2.microsoft.com/en-us/library/ms532292.aspx)
void *bits; void* bits;
HBITMAP source_hbitmap = HBITMAP source_hbitmap =
::CreateDIBSection(dc, &bm_info, DIB_RGB_COLORS, &bits, NULL, 0); ::CreateDIBSection(dc, &bm_info, DIB_RGB_COLORS, &bits, NULL, 0);
...@@ -760,8 +778,21 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) { ...@@ -760,8 +778,21 @@ void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
::ReleaseDC(NULL, dc); ::ReleaseDC(NULL, dc);
} }
void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap, void ClipboardWin::WriteData(const FormatType& format,
const gfx::Size& size) { const char* data_data,
size_t data_len) {
HGLOBAL hdata = ::GlobalAlloc(GMEM_MOVEABLE, data_len);
if (!hdata)
return;
char* data = static_cast<char*>(::GlobalLock(hdata));
memcpy(data, data_data, data_len);
::GlobalUnlock(data);
WriteToClipboard(format.ToFormatEtc().cfFormat, hdata);
}
void ClipboardWin::WriteBitmapFromHandle(HBITMAP source_hbitmap,
const gfx::Size& size) {
// We would like to just call ::SetClipboardData on the source_hbitmap, // We would like to just call ::SetClipboardData on the source_hbitmap,
// but that bitmap might not be of a sort we can write to the clipboard. // but that bitmap might not be of a sort we can write to the clipboard.
// For this reason, we create a new bitmap, copy the bits over, and then // For this reason, we create a new bitmap, copy the bits over, and then
...@@ -786,8 +817,17 @@ void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap, ...@@ -786,8 +817,17 @@ void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap,
// Now we need to blend it into an HBITMAP we can place on the clipboard // Now we need to blend it into an HBITMAP we can place on the clipboard
BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA}; BLENDFUNCTION bf = {AC_SRC_OVER, 0, 255, AC_SRC_ALPHA};
::GdiAlphaBlend(compatible_dc, 0, 0, size.width(), size.height(), ::GdiAlphaBlend(compatible_dc,
source_dc, 0, 0, size.width(), size.height(), bf); 0,
0,
size.width(),
size.height(),
source_dc,
0,
0,
size.width(),
size.height(),
bf);
// Clean up all the handles we just opened // Clean up all the handles we just opened
::SelectObject(compatible_dc, old_hbitmap); ::SelectObject(compatible_dc, old_hbitmap);
...@@ -801,20 +841,7 @@ void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap, ...@@ -801,20 +841,7 @@ void Clipboard::WriteBitmapFromHandle(HBITMAP source_hbitmap,
WriteToClipboard(CF_BITMAP, hbitmap); WriteToClipboard(CF_BITMAP, hbitmap);
} }
void Clipboard::WriteData(const FormatType& format, void ClipboardWin::WriteToClipboard(unsigned int format, HANDLE handle) {
const char* data_data,
size_t data_len) {
HGLOBAL hdata = ::GlobalAlloc(GMEM_MOVEABLE, data_len);
if (!hdata)
return;
char* data = static_cast<char*>(::GlobalLock(hdata));
memcpy(data, data_data, data_len);
::GlobalUnlock(data);
WriteToClipboard(format.ToUINT(), hdata);
}
void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
DCHECK(clipboard_owner_->hwnd() != NULL); DCHECK(clipboard_owner_->hwnd() != NULL);
if (handle && !::SetClipboardData(format, handle)) { if (handle && !::SetClipboardData(format, handle)) {
DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError()); DCHECK(ERROR_CLIPBOARD_NOT_OPEN != GetLastError());
...@@ -822,15 +849,7 @@ void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) { ...@@ -822,15 +849,7 @@ void Clipboard::WriteToClipboard(unsigned int format, HANDLE handle) {
} }
} }
// static HWND ClipboardWin::GetClipboardWindow() const {
void Clipboard::FreeData(unsigned int format, HANDLE data) {
if (format == CF_BITMAP)
::DeleteObject(static_cast<HBITMAP>(data));
else
::GlobalFree(data);
}
HWND Clipboard::GetClipboardWindow() const {
if (!clipboard_owner_) if (!clipboard_owner_)
return NULL; return NULL;
......
ui/base/clipboard/clipboard_win.h 0 → 100644
View file @ 24f3d915
// Copyright 2014 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_WIN_H_
#define UI_BASE_CLIPBOARD_CLIPBOARD_WIN_H_
#include "ui/base/clipboard/clipboard.h"
#include "base/memory/scoped_ptr.h"
namespace ui {
class ClipboardWin : public Clipboard {
private:
friend class Clipboard;
ClipboardWin();
~ClipboardWin() override;
// Clipboard overrides:
uint64 GetSequenceNumber(ClipboardType type) override;
bool IsFormatAvailable(const FormatType& format,
ClipboardType type) const override;
void Clear(ClipboardType type) override;
void ReadAvailableTypes(ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) const override;
void ReadText(ClipboardType type, base::string16* result) const override;
void ReadAsciiText(ClipboardType type, std::string* result) const override;
void ReadHTML(ClipboardType type,
base::string16* markup,
std::string* src_url,
uint32* fragment_start,
uint32* fragment_end) const override;
void ReadRTF(ClipboardType type, std::string* result) const override;
SkBitmap ReadImage(ClipboardType type) const override;
void ReadCustomData(ClipboardType clipboard_type,
const base::string16& type,
base::string16* result) const override;
void ReadBookmark(base::string16* title, std::string* url) const override;
void ReadData(const FormatType& format, std::string* result) const override;
void WriteObjects(ClipboardType type, const ObjectMap& objects) override;
void WriteText(const char* text_data, size_t text_len) override;
void WriteHTML(const char* markup_data,
size_t markup_len,
const char* url_data,
size_t url_len) override;
void WriteRTF(const char* rtf_data, size_t data_len) override;
void WriteBookmark(const char* title_data,
size_t title_len,
const char* url_data,
size_t url_len) override;
void WriteWebSmartPaste() override;
void WriteBitmap(const SkBitmap& bitmap) override;
void WriteData(const FormatType& format,
const char* data_data,
size_t data_len) override;
void WriteBitmapFromHandle(HBITMAP source_hbitmap, const gfx::Size& size);
// Safely write to system clipboard. Free |handle| on failure.
void WriteToClipboard(unsigned int format, HANDLE handle);
// Return the window that should be the clipboard owner, creating it
// if neccessary. Marked const for lazily initialization by const methods.
HWND GetClipboardWindow() const;
// Mark this as mutable so const methods can still do lazy initialization.
mutable scoped_ptr<base::win::MessageWindow> clipboard_owner_;
DISALLOW_COPY_AND_ASSIGN(ClipboardWin);
};
} // namespace ui
#endif // UI_BASE_CLIPBOARD_CLIPBOARD_WIN_H_
ui/base/ui_base.gyp
View file @ 24f3d915
...@@ -61,15 +61,19 @@ ...@@ -61,15 +61,19 @@
'clipboard/clipboard.cc', 'clipboard/clipboard.cc',
'clipboard/clipboard.h', 'clipboard/clipboard.h',
'clipboard/clipboard_android.cc', 'clipboard/clipboard_android.cc',
'clipboard/clipboard_android_initialization.h', 'clipboard/clipboard_android.h',
'clipboard/clipboard_aura.cc', 'clipboard/clipboard_aura.cc',
'clipboard/clipboard_aura.h',
'clipboard/clipboard_aurax11.cc', 'clipboard/clipboard_aurax11.cc',
'clipboard/clipboard_aurax11.h',
'clipboard/clipboard_constants.cc', 'clipboard/clipboard_constants.cc',
'clipboard/clipboard_mac.h',
'clipboard/clipboard_mac.mm', 'clipboard/clipboard_mac.mm',
'clipboard/clipboard_types.h', 'clipboard/clipboard_types.h',
'clipboard/clipboard_util_win.cc', 'clipboard/clipboard_util_win.cc',
'clipboard/clipboard_util_win.h', 'clipboard/clipboard_util_win.h',
'clipboard/clipboard_win.cc', 'clipboard/clipboard_win.cc',
'clipboard/clipboard_win.h',
'clipboard/custom_data_helper.cc', 'clipboard/custom_data_helper.cc',
'clipboard/custom_data_helper.h', 'clipboard/custom_data_helper.h',
'clipboard/custom_data_helper_linux.cc', 'clipboard/custom_data_helper_linux.cc',
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment