Make Android Clipboard Keep Track of Last Modified Time

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_android.h"
 
+#include <algorithm>
+
 #include "base/android/context_utils.h"
 #include "base/android/jni_string.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
 #include "jni/Clipboard_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 
@@ skipping 24 matching lines @@
 const char kHTMLFormat[] = "html";
 const char kRTFFormat[] = "rtf";
 const char kBitmapFormat[] = "bitmap";
 const char kWebKitSmartPasteFormat[] = "webkit_smart";
 const char kBookmarkFormat[] = "bookmark";
 
 class ClipboardMap {
  public:
   ClipboardMap();
   std::string Get(const std::string& format);
+  int64_t GetLastClipboardChangeTimeInMillis();
   bool HasFormat(const std::string& format);
   void Set(const std::string& format, const std::string& data);
   void CommitToAndroidClipboard();
   void Clear();
 
  private:
   void UpdateFromAndroidClipboard();
   std::map<std::string, std::string> map_;
   base::Lock lock_;
 
+  int64_t last_clipboard_change_time_ms_;
+
   // Java class and methods for the Android ClipboardManager.
   ScopedJavaGlobalRef<jobject> clipboard_manager_;
 };
 base::LazyInstance<ClipboardMap>::Leaky g_map = LAZY_INSTANCE_INITIALIZER;
 
 ClipboardMap::ClipboardMap() {
   clipboard_manager_.Reset(Java_Clipboard_create(
       AttachCurrentThread(), base::android::GetApplicationContext()));
   DCHECK(clipboard_manager_.obj());
 }
 
 std::string ClipboardMap::Get(const std::string& format) {
   base::AutoLock lock(lock_);
   UpdateFromAndroidClipboard();
   std::map<std::string, std::string>::const_iterator it = map_.find(format);
   return it == map_.end() ? std::string() : it->second;
 }
 
+int64_t ClipboardMap::GetLastClipboardChangeTimeInMillis() {
+  base::AutoLock lock(lock_);
+  UpdateFromAndroidClipboard();
+  return last_clipboard_change_time_ms_;
+}
+
 bool ClipboardMap::HasFormat(const std::string& format) {
   base::AutoLock lock(lock_);
   UpdateFromAndroidClipboard();
   return base::ContainsKey(map_, format);
 }
 
 void ClipboardMap::Set(const std::string& format, const std::string& data) {
   base::AutoLock lock(lock_);
   map_[format] = data;
 }
@@ skipping 64 matching lines @@
 
   std::map<std::string, std::string> android_clipboard_state;
 
   ScopedJavaLocalRef<jstring> jtext =
       Java_Clipboard_getCoercedText(env, clipboard_manager_);
   ScopedJavaLocalRef<jstring> jhtml =
       Java_Clipboard_getHTMLText(env, clipboard_manager_);
 
   AddMapEntry(env, &android_clipboard_state, kPlainTextFormat, jtext);
   AddMapEntry(env, &android_clipboard_state, kHTMLFormat, jhtml);
+  last_clipboard_change_time_ms_ =
+      Java_Clipboard_getClipboardContentChangeTimeInMillis(env,
+                                                           clipboard_manager_);
 
   if (!MapIsSubset(android_clipboard_state, map_))
     android_clipboard_state.swap(map_);
 }
 
 }  // namespace
 
 // Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() {
 }
@@ skipping 221 matching lines @@
   DCHECK(CalledOnValidThread());
   NOTIMPLEMENTED();
 }
 
 void ClipboardAndroid::ReadData(const Clipboard::FormatType& format,
                                 std::string* result) const {
   DCHECK(CalledOnValidThread());
   *result = g_map.Get().Get(format.ToString());
 }
 
+base::Time ClipboardAndroid::GetClipboardLastModifiedTime() const {
+  DCHECK(CalledOnValidThread());
+  return base::Time::FromJavaTime(
+      g_map.Get().GetLastClipboardChangeTimeInMillis());
+}
+
 // Main entry point used to write several values in the clipboard.
 void ClipboardAndroid::WriteObjects(ClipboardType type,
                                     const ObjectMap& objects) {
   DCHECK(CalledOnValidThread());
   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);
@@ skipping 46 matching lines @@
   g_map.Get().Set(kBitmapFormat, packed);
 }
 
 void ClipboardAndroid::WriteData(const Clipboard::FormatType& format,
                                  const char* data_data,
                                  size_t data_len) {
   g_map.Get().Set(format.ToString(), std::string(data_data, data_len));
 }
 
 } // namespace ui