Add Clipboard::GetSequenceNumber test and fix Android.

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/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 27 matching lines @@
 // 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 kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
 const char kMimeTypeWebCustomData[] = "chromium/x-web-custom-data";
 
-class ClipboardMap {
+class ClipboardMap : public ClipboardChangeListener {
  public:
   ClipboardMap();
   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();
 
+  uint64 sequence_number() const { return sequence_number_; }
+
  private:
+  // Called from Java when the clipboard changes.
+  void OnChange(JNIEnv* env, jobject obj) OVERRIDE;
+
   void SyncWithAndroidClipboard();
   std::map<std::string, std::string> map_;
   base::Lock lock_;
 
   // Java class and methods for the Android ClipboardManager.
   ScopedJavaGlobalRef<jobject> clipboard_manager_;
+  uint64 sequence_number_;
 };
 base::LazyInstance<ClipboardMap>::Leaky g_map = LAZY_INSTANCE_INITIALIZER;
 
-ClipboardMap::ClipboardMap() {
+ClipboardMap::ClipboardMap() : sequence_number_(0) {
   JNIEnv* env = AttachCurrentThread();
   DCHECK(env);
 
   // Get the context.
   jobject context = base::android::GetApplicationContext();
   DCHECK(context);
 
   ScopedJavaLocalRef<jobject> local_ref =
       Java_Clipboard_create(env, context);
   DCHECK(local_ref.obj());
   clipboard_manager_.Reset(env, local_ref.Release());
+
+  Java_Clipboard_addChangeListener(
+      env, clipboard_manager_.obj(), reinterpret_cast<intptr_t>(this));
+  LOG(ERROR) << "Hello?";
 }
 
 std::string ClipboardMap::Get(const std::string& format) {
   base::AutoLock lock(lock_);
   SyncWithAndroidClipboard();
   std::map<std::string, std::string>::const_iterator it = map_.find(format);
   return it == map_.end() ? std::string() : it->second;
 }
 
 bool ClipboardMap::HasFormat(const std::string& format) {
@@ skipping 32 matching lines @@
   }
 }
 
 void ClipboardMap::Clear() {
   JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
   map_.clear();
   Java_Clipboard_setText(env, clipboard_manager_.obj(), NULL);
 }
 
+void ClipboardMap::OnChange(JNIEnv* env, jobject obj) {
+  LOG(ERROR) << "Ping";
+  // TODO(dcheng): We may or may not need a lock here.
+  ++sequence_number_;
+}
+
 // If the internal map contains a plain-text entry and it does not match that
 // in the Android clipboard, clear the map and insert the Android text into it.
 // If there is an HTML entry in the Android clipboard it gets inserted in the
 // map.
 void ClipboardMap::SyncWithAndroidClipboard() {
   lock_.AssertAcquired();
   JNIEnv* env = AttachCurrentThread();
 
   // Update the plain text clipboard entry
   std::map<std::string, std::string>::const_iterator it =
@@ skipping 76 matching lines @@
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   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(ClipboardType /* type */) {
   DCHECK(CalledOnValidThread());
-  // 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;
+  return g_map.Get().sequence_number();
 }
 
 bool Clipboard::IsFormatAvailable(const Clipboard::FormatType& format,
                                   ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   return g_map.Get().HasFormat(format.data());
 }
 
 void Clipboard::Clear(ClipboardType type) {
@@ skipping 142 matching lines @@
   return type;
 }
 
 // static
 const Clipboard::FormatType& Clipboard::GetPepperCustomDataFormatType() {
   CR_DEFINE_STATIC_LOCAL(FormatType, type, (kMimeTypePepperCustomData));
   return type;
 }
 
 void Clipboard::WriteText(const char* text_data, size_t text_len) {
+  DCHECK(CalledOnValidThread());
   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) {
+  DCHECK(CalledOnValidThread());
   g_map.Get().Set(kHTMLFormat, std::string(markup_data, markup_len));
 }
 
 void Clipboard::WriteRTF(const char* rtf_data, size_t data_len) {
+  DCHECK(CalledOnValidThread());
   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) {
+  DCHECK(CalledOnValidThread());
   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() {
+  DCHECK(CalledOnValidThread());
   g_map.Get().Set(kWebKitSmartPasteFormat, std::string());
 }
 
 // Note: we implement this to pass all unit tests but it is currently unclear
 // how some code would consume this.
 void Clipboard::WriteBitmap(const SkBitmap& bitmap) {
+  DCHECK(CalledOnValidThread());
   gfx::Size size(bitmap.width(), bitmap.height());
 
   std::string packed(reinterpret_cast<const char*>(&size), sizeof(size));
   {
     SkAutoLockPixels bitmap_lock(bitmap);
     packed += std::string(static_cast<const char*>(bitmap.getPixels()),
                           bitmap.getSize());
   }
   g_map.Get().Set(kBitmapFormat, packed);
 }
 
 void Clipboard::WriteData(const Clipboard::FormatType& format,
                           const char* data_data, size_t data_len) {
+  DCHECK(CalledOnValidThread());
   g_map.Get().Set(format.data(), std::string(data_data, data_len));
 }
 
 // See clipboard_android_initialization.h for more information.
 bool RegisterClipboardAndroid(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 } // namespace ui