Remove redundant android clipboard API calls from clipboard writing code

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 "base/android/jni_string.h"
 #include "base/lazy_instance.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 34 matching lines @@
 const char kMimeTypePepperCustomData[] = "chromium/x-pepper-custom-data";
 const char kMimeTypeWebCustomData[] = "chromium/x-web-custom-data";
 
 class ClipboardMap {
  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();
+  void CommitToClipboard();

[dcheng, 2015/03/18 03:42:46]

Probably should be "CommitToAndroidClipboard()". It's a bit confusing to read
otherwise.

 
  private:
   void SyncWithAndroidClipboard();
   std::map<std::string, std::string> map_;
   base::Lock lock_;
 
   // Java class and methods for the Android ClipboardManager.
   ScopedJavaGlobalRef<jobject> clipboard_manager_;
 };
 base::LazyInstance<ClipboardMap>::Leaky g_map = LAZY_INSTANCE_INITIALIZER;
@@ skipping 19 matching lines @@
   return it == map_.end() ? std::string() : it->second;
 }
 
 bool ClipboardMap::HasFormat(const std::string& format) {
   base::AutoLock lock(lock_);
   SyncWithAndroidClipboard();
   return ContainsKey(map_, format);
 }
 
 void ClipboardMap::Set(const std::string& format, const std::string& data) {
-  JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
-  SyncWithAndroidClipboard();
-
   map_[format] = data;
-  if (format == kPlainTextFormat) {
-    ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(env, data);
-    DCHECK(str.obj());
-
-    Java_Clipboard_setText(env, clipboard_manager_.obj(), str.obj());
-  } else if (format == kHTMLFormat) {
-    // Android's API for storing HTML content on the clipboard requires a plain-
-    // text representation to be available as well. ScopedClipboardWriter has a
-    // stable order for setting clipboard data, ensuring that plain-text data
-    // is available first. Do not write to the clipboard when only HTML data is
-    // available, because otherwise others apps may not be able to paste it.
-    if (!ContainsKey(map_, kPlainTextFormat))
-      return;
-
-    ScopedJavaLocalRef<jstring> html = ConvertUTF8ToJavaString(env, data);
-    ScopedJavaLocalRef<jstring> text = ConvertUTF8ToJavaString(
-        env, map_[kPlainTextFormat].c_str());
-
-    DCHECK(html.obj() && text.obj());
-    Java_Clipboard_setHTMLText(
-        env, clipboard_manager_.obj(), html.obj(), text.obj());
-  }
 }
 
 void ClipboardMap::Clear() {
   JNIEnv* env = AttachCurrentThread();
   base::AutoLock lock(lock_);
   map_.clear();
   Java_Clipboard_setText(env, clipboard_manager_.obj(), NULL);
 }
 
 // If the internal map contains a plain-text entry and it does not match that
@@ skipping 38 matching lines @@
       map_[kHTMLFormat] = android_string;
       return;
     }
   }
   it = map_.find(kHTMLFormat);
   if (it != map_.end()) {
     map_.erase(kHTMLFormat);
   }
 }
 
+void ClipboardMap::CommitToClipboard() {
+  JNIEnv* env = AttachCurrentThread();
+  base::AutoLock lock(lock_);
+  // Android's API for storing HTML content on the clipboard requires a plain-
+  // text representation to be available as well. ScopedClipboardWriter has a
+  // stable order for setting clipboard data, ensuring that plain-text data
+  // is available first. Do not write to the clipboard when only HTML data is
+  // available, because otherwise others apps may not be able to paste it.
+  if (ContainsKey(map_, kHTMLFormat) &&
+      ContainsKey(map_, kPlainTextFormat)) {
+    ScopedJavaLocalRef<jstring> text = ConvertUTF8ToJavaString(
+        env, map_[kPlainTextFormat].c_str());

[dcheng, 2015/03/18 03:42:46]

The c_str() here (and below) is superfluous.

+    DCHECK(text.obj());
+
+    if (!Java_Clipboard_isHTMLClipboardSupported(env)) {

[dcheng, 2015/03/18 03:42:46]

Why wasn't this check previously needed?

[dcheng, 2015/03/18 03:42:46]

Why wasn't this check previously needed?

+      Java_Clipboard_setText(env, clipboard_manager_.obj(), text.obj());
+      return;
+    }
+
+    ScopedJavaLocalRef<jstring> html = ConvertUTF8ToJavaString(
+        env, map_[kHTMLFormat].c_str());
+
+    DCHECK(html.obj());
+    Java_Clipboard_setHTMLText(
+        env, clipboard_manager_.obj(), html.obj(), text.obj());
+
+  } else if (ContainsKey(map_, kPlainTextFormat)) {
+    ScopedJavaLocalRef<jstring> str = ConvertUTF8ToJavaString(
+        env, map_[kPlainTextFormat].c_str());
+    DCHECK(str.obj());
+    Java_Clipboard_setText(env, clipboard_manager_.obj(), str.obj());
+  }
+}
+
 }  // namespace
 
 // Clipboard::FormatType implementation.
 Clipboard::FormatType::FormatType() {
 }
 
 Clipboard::FormatType::FormatType(const std::string& native_format)
     : data_(native_format) {
 }
 
@@ skipping 212 matching lines @@
 // 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);
   }
+  g_map.Get().CommitToClipboard();
 }
 
 void ClipboardAndroid::WriteText(const char* text_data, size_t text_len) {
   g_map.Get().Set(kPlainTextFormat, std::string(text_data, text_len));
 }
 
 void ClipboardAndroid::WriteHTML(const char* markup_data,
                                  size_t markup_len,
                                  const char* url_data,
                                  size_t url_len) {
@@ skipping 37 matching lines @@
                                  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);
 }
 
 } // namespace ui