Upstream the Android clipboard implementation

ui/base/clipboard/clipboard_android.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/base/clipboard/clipboard.h"
 
+#include "base/android/jni_string.h"
+#include "base/lazy_instance.h"
+#include "base/synchronization/lock.h"
+#include "base/utf_string_conversions.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/size.h"
 
+// Important note:
+// The Android clipboard system only supports text format. So we use the
+// Android system when some text is added or retrieved from the system. For
+// anything else, we currently store the value in some process wide static
+// variable protected by a lock. So the (non-text) clipboard will only work
+// within the same process.
+
+using base::android::AttachCurrentThread;
+using base::android::CheckException;
+using base::android::ClearException;
+using base::android::ConvertJavaStringToUTF16;
+using base::android::ConvertJavaStringToUTF8;
+using base::android::GetClass;
+using base::android::GetMethodID;
+using base::android::ScopedJavaLocalRef;
+
 namespace ui {
 
 namespace {
-
-// Various format we support.
+// Various formats we support.
 const char kPlainTextFormat[] = "text";
 const char kHTMLFormat[] = "html";
 const char kRTFFormat[] = "rtf";
 const char kBitmapFormat[] = "bitmap";
 const char kWebKitSmartPasteFormat[] = "webkit_smart";
 const char kBookmarkFormat[] = "bookmark";
 const char kMimeTypeWebCustomData[] = "chromium/x-web-custom-data";
 
+class ClipboardMap {
+  public:

[dcheng, 2012/06/30 03:28:42]

1-space indent for public/private

[cjhopman, 2012/07/02 17:29:11]

Done.

+    ClipboardMap();

[dcheng, 2012/06/30 03:28:42]

2 spaces, etc.

[cjhopman, 2012/07/02 17:29:11]

Done.

+    std::string Get(const std::string& format);
+    bool HasFormat(const std::string& format);
+    void Set(const std::string& format, const std::string& data);
+    void Clear();
+
+  private:
+    void ValidateWithLock();
+    std::map<std::string, std::string> map_;
+    base::Lock lock_;
+
+    // Java class and methods for the Android ClipboardManager.
+    base::android::ScopedJavaGlobalRef<jobject> clipboard_manager_;
+    jmethodID set_text_;
+    jmethodID get_text_;
+    jmethodID to_string_;
+};
+base::LazyInstance<ClipboardMap>::Leaky g_map = LAZY_INSTANCE_INITIALIZER;
+
+ClipboardMap::ClipboardMap() {
+  JNIEnv* env = AttachCurrentThread();
+  DCHECK(env);
+
+  // Get the context.
+  jobject context = base::android::GetApplicationContext();
+  DCHECK(context);
+
+  // Get the context class.
+  ScopedJavaLocalRef<jclass> context_class =
+      GetClass(env, "android/content/Context");
+
+  // Get the system service method.
+  jmethodID get_system_service = GetMethodID(env, context_class,
+      "getSystemService",  "(Ljava/lang/String;)Ljava/lang/Object;");
+
+  // Retrieve the system service.
+  ScopedJavaLocalRef<jstring> service_name(env, env->NewStringUTF("clipboard"));
+  clipboard_manager_.Reset(env, env->CallObjectMethod(context,
+      get_system_service, service_name.obj()));
+  DCHECK(clipboard_manager_.obj() && !ClearException(env));
+
+  // Retain a few methods we'll keep using.
+  ScopedJavaLocalRef<jclass> clipboard_class =
+      GetClass(env, "android/text/ClipboardManager");
+  set_text_ = GetMethodID(env, clipboard_class,
+                          "setText", "(Ljava/lang/CharSequence;)V");
+  get_text_ = GetMethodID(env, clipboard_class,
+                          "getText", "()Ljava/lang/CharSequence;");
+
+  // Will need to call toString as CharSequence is not always a String.
+  ScopedJavaLocalRef<jclass> charsequence_class =
+      GetClass(env, "java/lang/CharSequence");
+  to_string_ = GetMethodID(env, charsequence_class,
+                           "toString", "()Ljava/lang/String;");
+}
+
+std::string ClipboardMap::Get(const std::string& format) {
+  base::AutoLock lock(lock_);
+  ValidateWithLock();
+  return map_[format];
+}
+
+bool ClipboardMap::HasFormat(const std::string& format) {
+  return !Get(format).empty();

[dcheng, 2012/06/30 03:28:42]

Consider using ContainsKey() from base/stl_util.h

[cjhopman, 2012/07/02 17:29:11]

Added a comment to clarify. In addition, in Get() we may insert a "" for a key
that we don't have data for, and so we can't just check if the map contains the
key.  I'm not sure if I prefer this to using find()/!=end()/etc in Get().

[dcheng, 2012/07/02 20:22:30]

We should use find(). Get() shouldn't mutate the map. Then Get() and HasFormat()
can be made const, and this method can use the ContainsKey() helper.

[cjhopman, 2012/07/02 21:00:49]

Currently, the Validate() call can also mutate the map to sync it with the state
of the Android clipboard. This allows the Validate call to have the
postcondition that map_ is in sync and that map_[kPlainTextFormat] ==
[[Android's clipboard content]]. This simplifies the logic in all the other
functions (get/set/clear/has). Logically, Get and HasFormat are not actually
mutating the map (the mutation logically occurs when the Android clipboard was
changed).

Three possible next steps:
1. Leave it as is.
2. Change Get() to use find() and Has() to use ContainsKey but both still
Validate and sync the map_. (optionally make map_ mutable and the logically
const functions const)
3. Make Validate not mutate map_, and then the same for Get/Has and mark these
functions const.

Also, I think Validate could be renamed to something more appropriate like
SyncWithAndroidClipboard.

[dcheng, 2012/07/02 21:09:52]

Oh right, I forgot about Validate(). I would prefer option #2 and just leave the
const-ness alone.

[cjhopman, 2012/07/02 22:33:25]

Done. Required small change to Validate/Sync since we no longer treat an empty
string the same as no string.

+}
+
+void ClipboardMap::Set(const std::string& format, const std::string& data) {
+  JNIEnv* env = AttachCurrentThread();
+  base::AutoLock lock(lock_);
+  ValidateWithLock();
+
+  map_[format] = data;
+  if (format == kPlainTextFormat) {
+    ScopedJavaLocalRef<jstring> str(
+        env, env->NewStringUTF(data.c_str()));
+    DCHECK(str.obj() && !ClearException(env));
+    env->CallVoidMethod(clipboard_manager_.obj(), set_text_, str.obj());
+  }
+}
+
+void ClipboardMap::Clear() {
+  JNIEnv* env = AttachCurrentThread();
+  base::AutoLock lock(lock_);
+  map_.clear();
+  env->CallVoidMethod(clipboard_manager_.obj(), set_text_, NULL);
+}
+
+void ClipboardMap::ValidateWithLock() {
+  lock_.AssertAcquired();
+
+  JNIEnv* env = AttachCurrentThread();
+  ScopedJavaLocalRef<jobject> char_seq_text(
+      env, env->CallObjectMethod(clipboard_manager_.obj(), get_text_));
+  if (char_seq_text.is_null()) {
+    map_.clear();
+    return;
+  }
+
+  std::string internal_string = map_[kPlainTextFormat];

[dcheng, 2012/06/30 03:28:42]

You could use a const ref here to avoid a copy.

[cjhopman, 2012/07/02 17:29:11]

Done.

+  ScopedJavaLocalRef<jstring> tmp_string(env,
+      static_cast<jstring>(env->CallObjectMethod(char_seq_text.obj(),
+                                                 to_string_)));
+  std::string android_string = ConvertJavaStringToUTF8(tmp_string);
+  if (internal_string != android_string) {
+    map_.clear();
+    map_[kPlainTextFormat] = android_string;
+  }
+}
+
 }  // namespace
 
 Clipboard::FormatType::FormatType() {
 }
 
 Clipboard::FormatType::FormatType(const std::string& native_format)
     : data_(native_format) {
 }
 
 Clipboard::FormatType::~FormatType() {
 }
 
 std::string Clipboard::FormatType::Serialize() const {
   return data_;
 }
 
 // static
 Clipboard::FormatType Clipboard::FormatType::Deserialize(
     const std::string& serialization) {
   return FormatType(serialization);
 }
 
 bool Clipboard::FormatType::Equals(const FormatType& other) const {
   return data_ == other.data_;
 }
 
-Clipboard::Clipboard() : set_text_(NULL), has_text_(NULL), get_text_(NULL) {
+Clipboard::Clipboard() {
 }
 
 Clipboard::~Clipboard() {
 }
 
+// Main entry point used to write several values in the clipboard.
 void Clipboard::WriteObjects(Buffer buffer, const ObjectMap& objects) {
+  g_map.Get().Clear();
+  for (ObjectMap::const_iterator iter = objects.begin();
+       iter != objects.end(); ++iter) {
+    DispatchObject(static_cast<ObjectType>(iter->first), iter->second);
+  }
 }
 
 uint64 Clipboard::GetSequenceNumber(Clipboard::Buffer /* buffer */) {
+  // TODO: implement this. For now this interface will advertise
+  // that the clipboard never changes. That's fine as long as we
+  // don't rely on this signal.
   return 0;
 }
 
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   Clipboard::Buffer buffer) const {
-  return false;
+  DCHECK_EQ(buffer, BUFFER_STANDARD);
+  return g_map.Get().HasFormat(format.data());
 }
 
 void Clipboard::Clear(Buffer buffer) {
-
+  DCHECK_EQ(buffer, BUFFER_STANDARD);
+  g_map.Get().Clear();
 }
 
 void Clipboard::ReadAvailableTypes(Buffer buffer, std::vector<string16>* types,
                                    bool* contains_filenames) const {
+  DCHECK_EQ(buffer, BUFFER_STANDARD);
+
+  if (!types || !contains_filenames) {
+    NOTREACHED();
+    return;
+  }
+
+  NOTIMPLEMENTED();
+
+  types->clear();
+  *contains_filenames = false;
 }
 
 void Clipboard::ReadText(Clipboard::Buffer buffer, string16* result) const {
+  std::string utf8;
+  ReadAsciiText(buffer, &utf8);
+  *result = UTF8ToUTF16(utf8);
 }
 
 void Clipboard::ReadAsciiText(Clipboard::Buffer buffer,
                               std::string* result) const {
+  DCHECK_EQ(buffer, BUFFER_STANDARD);
+  *result = g_map.Get().Get(kPlainTextFormat);
 }
 
+// Note: |src_url| isn't really used. It is only implemented in Windows
 void Clipboard::ReadHTML(Clipboard::Buffer buffer,
                          string16* markup,
                          std::string* src_url,
                          uint32* fragment_start,
                          uint32* fragment_end) const {
+  if (src_url)
+    src_url->clear();
+  *fragment_start = 0;
+
+  std::string input = g_map.Get().Get(kHTMLFormat);
+
+  *fragment_end = static_cast<uint32>(input.length());

[dcheng, 2012/06/30 03:28:42]

This should be markup->length() after the conversion.

[cjhopman, 2012/07/02 17:29:11]

Done.

+  *markup = UTF8ToUTF16(input);
 }
 
 void Clipboard::ReadRTF(Buffer buffer, std::string* result) const {
+  NOTIMPLEMENTED();
 }
 
 SkBitmap Clipboard::ReadImage(Buffer buffer) const {
-  return SkBitmap();
+  std::string input = g_map.Get().Get(kBitmapFormat);
+
+  SkBitmap bmp;
+  if (!input.empty()) {
+    DCHECK_LE(sizeof(gfx::Size), input.size());
+    const gfx::Size* size = reinterpret_cast<const gfx::Size*>(input.c_str());
+
+    bmp.setConfig(
+        SkBitmap::kARGB_8888_Config, size->width(), size->height(), 0);
+    bmp.allocPixels();
+
+    int bm_size = size->width() * size->height() * 4;
+    DCHECK_EQ(sizeof(gfx::Size) + bm_size, input.size());
+
+    memcpy(bmp.getPixels(), input.c_str() + sizeof(gfx::Size), bm_size);
+  }
+  return bmp;
 }
 
 void Clipboard::ReadCustomData(Buffer buffer,
                                const string16& type,
                                string16* result) const {
+  NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadBookmark(string16* title, std::string* url) const {
+  NOTIMPLEMENTED();
 }
 
 void Clipboard::ReadData(const Clipboard::FormatType& format,
                          std::string* result) const {
+  *result = g_map.Get().Get(format.data());
 }
 
 // static
 Clipboard::FormatType Clipboard::GetFormatType(
     const std::string& format_string) {
   return FormatType::Deserialize(format_string);
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPlainTextFormatType() {
@@ skipping 31 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetWebCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypeWebCustomData));
   return type;
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
+  g_map.Get().Set(kPlainTextFormat, std::string(text_data, text_len));
 }
 
 void Clipboard::WriteHTML(const char* markup_data,
                           size_t markup_len,
                           const char* url_data,
                           size_t url_len) {
+  static const char* html_prefix = "<meta http-equiv=\"content-type\" "

[dcheng, 2012/06/30 03:28:42]

Do you actually need this? Since only Android Chrome can see this string, and we
(presumably) always know the encoding, we shouldn't need to set this <meta> tag.

[cjhopman, 2012/07/02 17:29:11]

Done.

+                                   "content=\"text/html; charset=utf-8\">";
+  g_map.Get().Set(
+      kHTMLFormat, html_prefix + std::string(markup_data, markup_len));
 }
 
 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+  NOTIMPLEMENTED();
 }
 
+// Note: according to other platforms implementations, this really writes the
+// URL spec.
 void Clipboard::WriteBookmark(const char* title_data, size_t title_len,
                               const char* url_data, size_t 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
+// pasteboard. This flavor has no data.
 void Clipboard::WriteWebSmartPaste() {
+  g_map.Get().Set(kWebKitSmartPasteFormat, std::string(""));

[dcheng, 2012/06/30 03:28:42]

std::string() instead of std::string("")

[cjhopman, 2012/07/02 17:29:11]

Done.

 }
 
+// All platforms use gfx::Size for size data but it is passed as a const char*
+// Further, pixel_data is expected to be 32 bits per pixel
+// Note: we implement this to pass all unit tests but it is currently unclear
+// how some code would consume this.
 void Clipboard::WriteBitmap(const char* pixel_data, const char* size_data) {
+  const gfx::Size* size = reinterpret_cast<const gfx::Size*>(size_data);
+  int bm_size = size->width() * size->height() * 4;
+
+  std::string packed(size_data, sizeof(gfx::Size));
+  packed += std::string(pixel_data, bm_size);
+  g_map.Get().Set(kBitmapFormat, packed);
 }
 
 void Clipboard::WriteData(const Clipboard::FormatType& format,
                           const char* data_data, size_t data_len) {
+  g_map.Get().Set(format.data(), std::string(data_data, data_len));
 }
 
-bool Clipboard::IsTextAvailableFromAndroid() const {
-  return false;
-}
-
-void Clipboard::ValidateInternalClipboard() const {
-}
-
-void Clipboard::Clear() {
-}
-
-void Clipboard::ClearInternalClipboard() const {
-}
-
-void Clipboard::Set(const std::string& key, const std::string& value) {
-}
-
-}  // namespace ui
+} // namespace ui