BASELINE: Update Chromium to 47.0.2526.14

Also adding in sources needed for spellchecking.

Change-Id: Idd44170fa1616f26315188970a8d5ba7d472b18a
Reviewed-by: Michael Brüning <michael.bruning@theqtcompany.com>

7 files changed, 122 insertions, 73 deletions

diff --git a/chromium/ui/base/clipboard/clipboard.h b/chromium/ui/base/clipboard/clipboard.h
index 6c23a6da061..af8f439ce1e 100644
--- a/chromium/ui/base/clipboard/clipboard.h
+++ b/chromium/ui/base/clipboard/clipboard.h
@@ -11,7 +11,6 @@
 
 #include "base/compiler_specific.h"
 #include "base/lazy_instance.h"
-#include "base/memory/shared_memory.h"
 #include "base/process/process.h"
 #include "base/strings/string16.h"
 #include "base/synchronization/lock.h"
diff --git a/chromium/ui/base/clipboard/clipboard_android.cc b/chromium/ui/base/clipboard/clipboard_android.cc
index abeb9e92ffc..1a0d0f93724 100644
--- a/chromium/ui/base/clipboard/clipboard_android.cc
+++ b/chromium/ui/base/clipboard/clipboard_android.cc
@@ -51,10 +51,11 @@ class 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 CommitToAndroidClipboard();
   void Clear();
 
  private:
-  void SyncWithAndroidClipboard();
+  void UpdateFromAndroidClipboard();
   std::map<std::string, std::string> map_;
   base::Lock lock_;
 
@@ -71,52 +72,54 @@ ClipboardMap::ClipboardMap() {
   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());
+  clipboard_manager_.Reset(Java_Clipboard_create(env, context));
+  DCHECK(clipboard_manager_.obj());
 }
 
 std::string ClipboardMap::Get(const std::string& format) {
   base::AutoLock lock(lock_);
-  SyncWithAndroidClipboard();
+  UpdateFromAndroidClipboard();
   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) {
   base::AutoLock lock(lock_);
-  SyncWithAndroidClipboard();
+  UpdateFromAndroidClipboard();
   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) {
+void ClipboardMap::CommitToAndroidClipboard() {
+  JNIEnv* env = AttachCurrentThread();
+  base::AutoLock lock(lock_);
+  if (ContainsKey(map_, 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.
+    // text representation to be available as well.
     if (!ContainsKey(map_, kPlainTextFormat))
       return;
 
-    ScopedJavaLocalRef<jstring> html = ConvertUTF8ToJavaString(env, data);
-    ScopedJavaLocalRef<jstring> text = ConvertUTF8ToJavaString(
-        env, map_[kPlainTextFormat].c_str());
+    ScopedJavaLocalRef<jstring> html =
+        ConvertUTF8ToJavaString(env, map_[kHTMLFormat].c_str());
+    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());
+    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());
+  } else {
+    Java_Clipboard_setText(env, clipboard_manager_.obj(), nullptr);
+    NOTIMPLEMENTED();
   }
 }
 
@@ -127,49 +130,48 @@ void ClipboardMap::Clear() {
   Java_Clipboard_setText(env, clipboard_manager_.obj(), NULL);
 }
 
-// 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() {
+// 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() {
+  // Fetch the current Android clipboard state. Replace our state with
+  // the Android state if the Android state has been changed.
   lock_.AssertAcquired();
   JNIEnv* env = AttachCurrentThread();
 
-  // Update the plain text clipboard entry
-  std::map<std::string, std::string>::const_iterator it =
-    map_.find(kPlainTextFormat);
-  ScopedJavaLocalRef<jstring> java_string_text =
-      Java_Clipboard_getCoercedText(env, clipboard_manager_.obj());
-  if (java_string_text.obj()) {
-    std::string android_string = ConvertJavaStringToUTF8(java_string_text);
-    if (!android_string.empty() &&
-        (it == map_.end() || it->second != android_string)) {
-      // There is a different string in the Android clipboard than we have.
-      // Clear the map on our side.
-      map_.clear();
-      map_[kPlainTextFormat] = android_string;
-    }
-  } else {
-    if (it != map_.end()) {
-      // We have plain text on this side, but Android doesn't. Nuke ours.
-      map_.clear();
-    }
-  }
+  std::map<std::string, std::string> android_clipboard_state;
 
-  // Update the html clipboard entry
-  ScopedJavaLocalRef<jstring> java_string_html =
+  ScopedJavaLocalRef<jstring> jtext =
+      Java_Clipboard_getCoercedText(env, clipboard_manager_.obj());
+  ScopedJavaLocalRef<jstring> jhtml =
       Java_Clipboard_getHTMLText(env, clipboard_manager_.obj());
-  if (java_string_html.obj()) {
-    std::string android_string = ConvertJavaStringToUTF8(java_string_html);
-    if (!android_string.empty()) {
-      map_[kHTMLFormat] = android_string;
-      return;
-    }
-  }
-  it = map_.find(kHTMLFormat);
-  if (it != map_.end()) {
-    map_.erase(kHTMLFormat);
-  }
+
+  AddMapEntry(env, &android_clipboard_state, kPlainTextFormat, jtext);
+  AddMapEntry(env, &android_clipboard_state, kHTMLFormat, jhtml);
+
+  if (!MapIsSubset(android_clipboard_state, map_))
+    android_clipboard_state.swap(map_);
 }
 
 }  // namespace
@@ -311,9 +313,21 @@ void ClipboardAndroid::ReadAvailableTypes(ClipboardType type,
     return;
   }
 
-  NOTIMPLEMENTED();
-
   types->clear();
+
+  // would be nice to ask the ClipboardMap to enumerate the types it supports,
+  // rather than hardcode the list here.
+  if (IsFormatAvailable(Clipboard::GetPlainTextFormatType(), type))
+    types->push_back(base::UTF8ToUTF16(kMimeTypeText));
+  if (IsFormatAvailable(Clipboard::GetHtmlFormatType(), type))
+    types->push_back(base::UTF8ToUTF16(kMimeTypeHTML));
+
+  // these formats aren't supported by the ClipboardMap currently, but might
+  // be one day?
+  if (IsFormatAvailable(Clipboard::GetRtfFormatType(), type))
+    types->push_back(base::UTF8ToUTF16(kMimeTypeRTF));
+  if (IsFormatAvailable(Clipboard::GetBitmapFormatType(), type))
+    types->push_back(base::UTF8ToUTF16(kMimeTypePNG));
   *contains_filenames = false;
 }
 
@@ -400,10 +414,13 @@ void ClipboardAndroid::WriteObjects(ClipboardType type,
   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().CommitToAndroidClipboard();
 }
 
 void ClipboardAndroid::WriteText(const char* text_data, size_t text_len) {
diff --git a/chromium/ui/base/clipboard/clipboard_aurax11.cc b/chromium/ui/base/clipboard/clipboard_aurax11.cc
index de56858dffc..b9b53f18f36 100644
--- a/chromium/ui/base/clipboard/clipboard_aurax11.cc
+++ b/chromium/ui/base/clipboard/clipboard_aurax11.cc
@@ -71,7 +71,7 @@ class SelectionChangeObserver : public ui::PlatformEventObserver {
   uint64 primary_sequence_number() const { return primary_sequence_number_; }
 
  private:
-  friend struct DefaultSingletonTraits<SelectionChangeObserver>;
+  friend struct base::DefaultSingletonTraits<SelectionChangeObserver>;
 
   SelectionChangeObserver();
   ~SelectionChangeObserver() override;
@@ -119,7 +119,7 @@ SelectionChangeObserver::~SelectionChangeObserver() {
 }
 
 SelectionChangeObserver* SelectionChangeObserver::GetInstance() {
-  return Singleton<SelectionChangeObserver>::get();
+  return base::Singleton<SelectionChangeObserver>::get();
 }
 
 void SelectionChangeObserver::WillProcessEvent(const ui::PlatformEvent& event) {
diff --git a/chromium/ui/base/clipboard/clipboard_mac.mm b/chromium/ui/base/clipboard/clipboard_mac.mm
index e42a49f772d..62331947ddf 100644
--- a/chromium/ui/base/clipboard/clipboard_mac.mm
+++ b/chromium/ui/base/clipboard/clipboard_mac.mm
@@ -11,7 +11,6 @@
 #include "base/logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
-#import "base/mac/scoped_nsexception_enabler.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/stl_util.h"
 #include "base/strings/sys_string_conversions.h"
@@ -307,9 +306,12 @@ SkBitmap ClipboardMac::ReadImage(ClipboardType type) const {
   // If the pasteboard's image data is not to its liking, the guts of NSImage
   // may throw, and that exception will leak. Prevent a crash in that case;
   // a blank image is better.
-  base::scoped_nsobject<NSImage> image(base::mac::RunBlockIgnoringExceptions(^{
-      return [[NSImage alloc] initWithPasteboard:GetPasteboard()];
-  }));
+  base::scoped_nsobject<NSImage> image;
+  @try {
+    image.reset([[NSImage alloc] initWithPasteboard:GetPasteboard()]);
+  } @catch (id exception) {
+  }
+
   SkBitmap bitmap;
   if (image.get()) {
     bitmap = gfx::NSImageToSkBitmapWithColorSpace(
diff --git a/chromium/ui/base/clipboard/clipboard_test_template.h b/chromium/ui/base/clipboard/clipboard_test_template.h
index 844266bcf6b..2b298da68d9 100644
--- a/chromium/ui/base/clipboard/clipboard_test_template.h
+++ b/chromium/ui/base/clipboard/clipboard_test_template.h
@@ -23,6 +23,7 @@
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "testing/gmock/include/gmock/gmock-matchers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ -46,6 +47,8 @@ using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 
+using testing::Contains;
+
 namespace ui {
 
 template <typename ClipboardTraits>
@@ -64,6 +67,13 @@ class ClipboardTest : public PlatformTest {
  protected:
   Clipboard& clipboard() { return *clipboard_; }
 
+  std::vector<base::string16> GetAvailableTypes(ClipboardType type) {
+    bool contains_filenames;
+    std::vector<base::string16> types;
+    clipboard().ReadAvailableTypes(type, &types, &contains_filenames);
+    return types;
+  }
+
  private:
   base::MessageLoopForUI message_loop_;
 #if defined(USE_AURA)
@@ -89,6 +99,7 @@ TYPED_TEST(ClipboardTest, ClearTest) {
 
   this->clipboard().Clear(CLIPBOARD_TYPE_COPY_PASTE);
 
+  EXPECT_TRUE(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE).empty());
   EXPECT_FALSE(this->clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_FALSE(this->clipboard().IsFormatAvailable(
@@ -104,6 +115,8 @@ TYPED_TEST(ClipboardTest, TextTest) {
     clipboard_writer.WriteText(text);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeText)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
@@ -126,6 +139,8 @@ TYPED_TEST(ClipboardTest, HTMLTest) {
     clipboard_writer.WriteHTML(markup, url);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeHTML)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetHtmlFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   uint32 fragment_start;
@@ -153,6 +168,8 @@ TYPED_TEST(ClipboardTest, RTFTest) {
     clipboard_writer.WriteRTF(rtf);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeRTF)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(Clipboard::GetRtfFormatType(),
                                                   CLIPBOARD_TYPE_COPY_PASTE));
   std::string result;
@@ -178,6 +195,11 @@ TYPED_TEST(ClipboardTest, MultipleBufferTest) {
     clipboard_writer.WriteHTML(markup, url);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeText)));
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_SELECTION),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeHTML)));
+
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_FALSE(this->clipboard().IsFormatAvailable(
@@ -214,6 +236,8 @@ TYPED_TEST(ClipboardTest, TrickyHTMLTest) {
     clipboard_writer.WriteHTML(markup, url);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeHTML)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetHtmlFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   uint32 fragment_start;
@@ -242,6 +266,8 @@ TYPED_TEST(ClipboardTest, UnicodeHTMLTest) {
     clipboard_writer.WriteHTML(markup, url);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeHTML)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetHtmlFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   uint32 fragment_start;
@@ -287,6 +313,10 @@ TYPED_TEST(ClipboardTest, MultiFormatTest) {
     clipboard_writer.WriteText(text);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeHTML)));
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeText)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetHtmlFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
@@ -319,6 +349,8 @@ TYPED_TEST(ClipboardTest, URLTest) {
     clipboard_writer.WriteURL(url);
   }
 
+  EXPECT_THAT(this->GetAvailableTypes(CLIPBOARD_TYPE_COPY_PASTE),
+              Contains(ASCIIToUTF16(Clipboard::kMimeTypeText)));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(this->clipboard().IsFormatAvailable(
diff --git a/chromium/ui/base/clipboard/clipboard_util_win.cc b/chromium/ui/base/clipboard/clipboard_util_win.cc
index 91d58a0a4ce..c0c05b054bb 100644
--- a/chromium/ui/base/clipboard/clipboard_util_win.cc
+++ b/chromium/ui/base/clipboard/clipboard_util_win.cc
@@ -473,7 +473,7 @@ void ClipboardUtil::CFHtmlExtractMetadata(const std::string& cf_html,
   // If the comments cannot be found, like copying from OpenOffice Writer,
   // we simply fall back to using StartFragment/EndFragment bytecount values
   // to determine the fragment indexes.
-  std::string cf_html_lower = base::StringToLowerASCII(cf_html);
+  std::string cf_html_lower = base::ToLowerASCII(cf_html);
   size_t markup_start = cf_html_lower.find("<html", 0);
   if (html_start) {
     *html_start = markup_start;
diff --git a/chromium/ui/base/clipboard/clipboard_win.cc b/chromium/ui/base/clipboard/clipboard_win.cc
index e818f2240d9..2743755dfd4 100644
--- a/chromium/ui/base/clipboard/clipboard_win.cc
+++ b/chromium/ui/base/clipboard/clipboard_win.cc
@@ -15,7 +15,6 @@
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"