Clipboard Android - Store and Read Last Modified Time from Prefs

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 <utility>
 
 #include "base/android/context_utils.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
+#include "base/callback.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,
@@ skipping 23 matching lines @@
 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();
+  void SetModifiedCallback(ClipboardAndroid::ModifiedCallback cb);
   std::string Get(const std::string& format);
   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();
 
+  // Unlike the functions above, does not call |modified_cb_|.
+  void SetLastModifiedTimeWithoutRunningCallback(base::Time time);
+
  private:
   enum class MapState {
     kOutOfDate,
     kUpToDate,
     kPreparingCommit,
   };
 
+  // Updates |last_modified_time_| to |time| and writes it to |local_state_|.
+  void UpdateLastModifiedTime(base::Time time);
+
+  // Updates |map_| and |map_state_| if necessary by fetching data from Java.
   void UpdateFromAndroidClipboard();
+
   std::map<std::string, std::string> map_;
   MapState map_state_;
   base::Lock lock_;
 
   uint64_t sequence_number_;
   base::Time last_modified_time_;
 
+  ClipboardAndroid::ModifiedCallback modified_cb_;
+
   // Java class and methods for the Android ClipboardManager.
   ScopedJavaGlobalRef<jobject> clipboard_manager_;
 };
 base::LazyInstance<ClipboardMap>::Leaky g_map = LAZY_INSTANCE_INITIALIZER;
 
 ClipboardMap::ClipboardMap() : map_state_(MapState::kOutOfDate) {
   clipboard_manager_.Reset(Java_Clipboard_getInstance(AttachCurrentThread()));
   DCHECK(clipboard_manager_.obj());
 }
 
+void ClipboardMap::SetModifiedCallback(ClipboardAndroid::ModifiedCallback cb) {
+  modified_cb_ = std::move(cb);
+}
+
 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;
 }
 
 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();
+  UpdateLastModifiedTime(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();
+  UpdateLastModifiedTime(base::Time::Now());
   map_state_ = MapState::kOutOfDate;
 }
 
 void ClipboardMap::Set(const std::string& format, const std::string& data) {
   base::AutoLock lock(lock_);
   map_[format] = data;
   map_state_ = MapState::kPreparingCommit;
 }
 
 void ClipboardMap::CommitToAndroidClipboard() {
@@ skipping 16 matching lines @@
     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_state_ = MapState::kUpToDate;
   sequence_number_++;
-  last_modified_time_ = base::Time::Now();
+  UpdateLastModifiedTime(base::Time::Now());
 }
 
 void ClipboardMap::Clear() {
   JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
   map_.clear();
   Java_Clipboard_clear(env, clipboard_manager_);
   map_state_ = MapState::kUpToDate;
   sequence_number_++;
-  last_modified_time_ = base::Time::Now();
+  UpdateLastModifiedTime(base::Time::Now());
+}
+
+void ClipboardMap::SetLastModifiedTimeWithoutRunningCallback(base::Time time) {
+  last_modified_time_ = time;
 }
 
 // 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;
   }
 }
 
+void ClipboardMap::UpdateLastModifiedTime(base::Time time) {
+  last_modified_time_ = time;
+  // |modified_callback_| may be null in tests.
+  if (modified_cb_)
+    modified_cb_.Run(time);
+}
+
 void ClipboardMap::UpdateFromAndroidClipboard() {
   DCHECK_NE(MapState::kPreparingCommit, map_state_);
   if (map_state_ == MapState::kUpToDate)
     return;
 
   // Fetch the current Android clipboard state.
   lock_.AssertAcquired();
   JNIEnv* env = AttachCurrentThread();
 
   ScopedJavaLocalRef<jstring> jtext =
@@ skipping 106 matching lines @@
 }
 
 // ClipboardAndroid implementation.
 
 void ClipboardAndroid::OnPrimaryClipChanged(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& obj) {
   g_map.Get().OnPrimaryClipboardChanged();
 }
 
+void ClipboardAndroid::SetModifiedCallback(ModifiedCallback cb) {
+  g_map.Get().SetModifiedCallback(std::move(cb));
+}
+
+void ClipboardAndroid::SetLastModifiedTimeWithoutRunningCallback(
+    base::Time time) {
+  g_map.Get().SetLastModifiedTimeWithoutRunningCallback(time);
+}
+
 ClipboardAndroid::ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
 ClipboardAndroid::~ClipboardAndroid() {
   DCHECK(CalledOnValidThread());
 }
 
 void ClipboardAndroid::OnPreShutdown() {}
 
@@ skipping 197 matching lines @@
   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