Refactor Clipboard Last Modified Time Storage

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/android/scoped_java_ref.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "base/time/time.h"
 #include "jni/Clipboard_jni.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/geometry/size.h"
 
 // TODO:(andrewhayden) Support additional formats in Android: Bitmap, URI, HTML,
 // HTML+text now that Android's clipboard system supports them, then nuke the
 // legacy implementation note below.
 
 // Legacy implementation note:
 // The Android clipboard system used to only support text format. So we used the
 // Android system when some text was added or retrieved from the system. For
 // anything else, we STILL 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::ClearException;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ScopedJavaGlobalRef;
 using base::android::ScopedJavaLocalRef;
 
 namespace ui {
 
 namespace {
+
 // Various formats we support.
 const char kURLFormat[] = "url";
 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";
 
 class ClipboardMap {
  public:
   ClipboardMap();
   std::string Get(const std::string& format);
-  int64_t GetLastClipboardChangeTimeInMillis();
+  uint64_t GetSequenceNumber() const;
+  base::Time GetLastModifiedTime() const;
+  void ClearLastModifiedTime();
   bool HasFormat(const std::string& format);
+  void OnPrimaryClipboardChanged();
   void Set(const std::string& format, const std::string& data);
   void CommitToAndroidClipboard();
   void Clear();
 
  private:
   void UpdateFromAndroidClipboard();
   std::map<std::string, std::string> map_;
+  bool map_up_to_date_;
   base::Lock lock_;
 
-  int64_t last_clipboard_change_time_ms_;
+  uint64_t sequence_number_;
+  base::Time last_modified_time_;
 
   // 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_getInstance(AttachCurrentThread()));
   DCHECK(clipboard_manager_.obj());
+  map_up_to_date_ = false;

[dcheng, 2017/04/13 20:35:37]

Nit: use the initializer list (or use in-class initialization)

[Mark P, 2017/04/13 20:54:05]

Done.

 }
 
 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_;
+uint64_t ClipboardMap::GetSequenceNumber() const {
+  return sequence_number_;
+}
+
+base::Time ClipboardMap::GetLastModifiedTime() const {
+  return last_modified_time_;
+}
+
+void ClipboardMap::ClearLastModifiedTime() {
+  last_modified_time_ = base::Time();
 }
 
 bool ClipboardMap::HasFormat(const std::string& format) {
   base::AutoLock lock(lock_);
   UpdateFromAndroidClipboard();
   return base::ContainsKey(map_, format);
 }
 
+void ClipboardMap::OnPrimaryClipboardChanged() {
+  sequence_number_++;
+  last_modified_time_ = base::Time::Now();
+  map_up_to_date_ = false;
+}
+
 void ClipboardMap::Set(const std::string& format, const std::string& data) {
   base::AutoLock lock(lock_);
   map_[format] = data;
+  map_up_to_date_ = false;

[dcheng, 2017/04/13 20:35:37]

Can we make this a tri-state enum? Calling UpdateFromAndroidClipboard() in this
state should be considered an error (since this would blow away the temporary
state that we're trying to commit to the clipboard).

[Mark P, 2017/04/13 20:54:05]

Do you mean
MAP_OUT_OF_DATE
MAP_FRESHER_THAN_JAVA
MAP_UP_TO_DATE
?

And DCHECK if UpdateFromAndroidClipboard() is called from the middle state?

[dcheng, 2017/04/13 20:59:18]

MAP_OUT_OF_DATE
MAP_UP_TO_DATE
MAP_PREPARING_COMMIT

would be my suggestions or if you want to use scoped enums

enum class MapState {
  kOutOfDate,
  kUpToDate,
  kPreparingCommit,
};

[Mark P, 2017/04/13 21:21:46]

Done with the scoped enum.  Please take a look.

Thanks by the way for your suggestion of names.  "Preparing commit" is much
better than "fresher than java".

 }
 
 void ClipboardMap::CommitToAndroidClipboard() {
   JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
   if (base::ContainsKey(map_, kHTMLFormat)) {
     // Android's API for storing HTML content on the clipboard requires a plain-
     // text representation to be available as well.
     if (!base::ContainsKey(map_, kPlainTextFormat))
       return;
 
     ScopedJavaLocalRef<jstring> html =
         ConvertUTF8ToJavaString(env, map_[kHTMLFormat]);
     ScopedJavaLocalRef<jstring> text =
         ConvertUTF8ToJavaString(env, map_[kPlainTextFormat]);
 
     DCHECK(html.obj() && text.obj());
     Java_Clipboard_setHTMLText(env, clipboard_manager_, html, text);
   } else if (base::ContainsKey(map_, kPlainTextFormat)) {
     ScopedJavaLocalRef<jstring> str =
         ConvertUTF8ToJavaString(env, map_[kPlainTextFormat]);
     DCHECK(str.obj());
     Java_Clipboard_setText(env, clipboard_manager_, str);
   } else {
     Java_Clipboard_clear(env, clipboard_manager_);
     NOTIMPLEMENTED();
   }
+  map_up_to_date_ = true;
+  sequence_number_++;
+  last_modified_time_ = base::Time::Now();
 }
 
 void ClipboardMap::Clear() {
   JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
   map_.clear();
   Java_Clipboard_clear(env, clipboard_manager_);
+  map_up_to_date_ = true;
+  sequence_number_++;
+  last_modified_time_ = base::Time::Now();
 }
 
 // Add a key:jstr pair to map, but only if jstr is not null, and also
 // not empty.
 void AddMapEntry(JNIEnv* env,
                  std::map<std::string, std::string>* map,
                  const char* key,
                  const ScopedJavaLocalRef<jstring>& jstr) {
   if (!jstr.is_null()) {
     std::string str = ConvertJavaStringToUTF8(env, jstr.obj());
     if (!str.empty())
       (*map)[key] = str;
   }
 }
 
-// Return true if all the key-value pairs in map1 are also in map2.
-bool MapIsSubset(const std::map<std::string, std::string>& map1,
-                 const std::map<std::string, std::string>& map2) {
-  for (const auto& val : map1) {
-    auto iter = map2.find(val.first);
-    if (iter == map2.end() || iter->second != val.second)
-      return false;
-  }
-  return true;
-}
+void ClipboardMap::UpdateFromAndroidClipboard() {
+  if (map_up_to_date_)
+    return;
 
-void ClipboardMap::UpdateFromAndroidClipboard() {
-  // Fetch the current Android clipboard state. Replace our state with
-  // the Android state if the Android state has been changed.
+  // Fetch the current Android clipboard state.
   lock_.AssertAcquired();
   JNIEnv* env = AttachCurrentThread();
 
-  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_);
+  AddMapEntry(env, &map_, kPlainTextFormat, jtext);
+  AddMapEntry(env, &map_, kHTMLFormat, jhtml);
 
-  if (!MapIsSubset(android_clipboard_state, map_))
-    android_clipboard_state.swap(map_);
+  map_up_to_date_ = true;
 }
 
 }  // namespace
 
 // Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() {
 }
 
 Clipboard::FormatType::FormatType(const std::string& native_format)
     : data_(native_format) {
@@ skipping 81 matching lines @@
   return type;
 }
 
 // Clipboard factory method.
 // static
 Clipboard* Clipboard::Create() {
   return new ClipboardAndroid;
 }
 
 // ClipboardAndroid implementation.
+
+void ClipboardAndroid::OnPrimaryClipChanged(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& obj) {
+  g_map.Get().OnPrimaryClipboardChanged();
+}
+
 ClipboardAndroid::ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
 ClipboardAndroid::~ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
 void ClipboardAndroid::OnPreShutdown() {}
 
 uint64_t ClipboardAndroid::GetSequenceNumber(ClipboardType /* type */) const {
   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().GetSequenceNumber();
 }
 
 bool ClipboardAndroid::IsFormatAvailable(const Clipboard::FormatType& format,
                                          ClipboardType type) const {
   DCHECK(CalledOnValidThread());
   DCHECK_EQ(type, CLIPBOARD_TYPE_COPY_PASTE);
   return g_map.Get().HasFormat(format.ToString());
 }
 
 void ClipboardAndroid::Clear(ClipboardType type) {
@@ skipping 101 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 {
+base::Time ClipboardAndroid::GetLastModifiedTime() const {
   DCHECK(CalledOnValidThread());
-  return base::Time::FromJavaTime(
-      g_map.Get().GetLastClipboardChangeTimeInMillis());
+  return g_map.Get().GetLastModifiedTime();
+}
+
+void ClipboardAndroid::ClearLastModifiedTime() {
+  DCHECK(CalledOnValidThread());
+  g_map.Get().ClearLastModifiedTime();
 }
 
 // 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();
@@ skipping 47 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));
 }
 
+bool RegisterClipboardAndroid(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+// Returns a pointer to the current ClipboardAndroid object.
+static jlong Init(JNIEnv* env,
+                  const base::android::JavaParamRef<jobject>& obj) {
+  return reinterpret_cast<intptr_t>(Clipboard::GetForCurrentThread());
+}
+
 } // namespace ui