Implement ui::ClipboardMus.

ui/base/clipboard/clipboard_test_template.h

 // 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.
 //
 // Note: This header doesn't use REGISTER_TYPED_TEST_CASE_P like most
 // type-parameterized gtests. There are lot of test cases in here that are only
 // enabled on certain platforms. However, preprocessor directives in macro
 // arguments result in undefined behavior (and don't work on MSVC). Instead,
 // 'parameterized' tests should typedef TypesToTest (which is used to
 // instantiate the tests using the TYPED_TEST_CASE macro) and then #include this
@@ skipping 38 matching lines @@
 
 using testing::Contains;
 
 namespace ui {
 
 template <typename ClipboardTraits>
 class ClipboardTest : public PlatformTest {
  public:
 #if defined(USE_AURA)
   ClipboardTest()
-      : event_source_(PlatformEventSource::CreateDefault()),
+      : event_source_(ClipboardTraits::GetEventSource()),
         clipboard_(ClipboardTraits::Create()) {}
 #else
   ClipboardTest() : clipboard_(ClipboardTraits::Create()) {}
 #endif
 
   ~ClipboardTest() override { ClipboardTraits::Destroy(clipboard_); }
 
+  bool IsMusTest() { return ClipboardTraits::IsMusTest(); }
+
  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)
   std::unique_ptr<PlatformEventSource> event_source_;
 #endif
   // ui::Clipboard has a protected destructor, so scoped_ptr doesn't work here.
   Clipboard* const clipboard_;
 };
 
 // Hack for tests that need to call static methods of ClipboardTest.
 struct NullClipboardTraits {
   static Clipboard* Create() { return nullptr; }
+  static bool IsMusTest() { return false; }
   static void Destroy(Clipboard*) {}
 };
 
 TYPED_TEST_CASE(ClipboardTest, TypesToTest);
 
 TYPED_TEST(ClipboardTest, ClearTest) {
   {
     ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(ASCIIToUTF16("clear me"));
   }
@@ skipping 260 matching lines @@
   this->clipboard().ReadText(CLIPBOARD_TYPE_COPY_PASTE, &text_result);
 
   EXPECT_EQ(text_result, url);
 
   std::string ascii_text;
   this->clipboard().ReadAsciiText(CLIPBOARD_TYPE_COPY_PASTE, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID) && \
     !defined(OS_CHROMEOS)
-  ascii_text.clear();
-  this->clipboard().ReadAsciiText(CLIPBOARD_TYPE_SELECTION, &ascii_text);
-  EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
+  if (!this->IsMusTest()) {

[dcheng, 2016/06/04 06:14:00]

Why do we exclude mus here? Wouldn't we expect this to work on Linux, even with
mus?

[Elliot Glaysher, 2016/06/06 20:10:12]

Because mus is chromeos in a linux build.

When chrome mus is enabled, any build of chrome can have --mus passed in to
activate ash. And ash doesn't have a selection clipboard.

(The other option is to always write to CLIPBOARD_TYPE_SELECTION in mus which
will usually be ignored. I think this is better.)

[dcheng, 2016/06/07 05:39:00]

It feels a bit odd, but I can live with this reasoning.

+    ascii_text.clear();
+    this->clipboard().ReadAsciiText(CLIPBOARD_TYPE_SELECTION, &ascii_text);
+    EXPECT_EQ(UTF16ToUTF8(url), ascii_text);
+  }
 #endif
 }
 
 static void TestBitmapWrite(Clipboard* clipboard,
                             const gfx::Size& size,
                             const uint32_t* bitmap_data) {
   {
     ScopedClipboardWriter scw(CLIPBOARD_TYPE_COPY_PASTE);
     SkBitmap bitmap;
     ASSERT_TRUE(bitmap.setInfo(
@@ skipping 288 matching lines @@
   ScopedClipboardWriter scw(CLIPBOARD_TYPE_COPY_PASTE);
   scw.WritePickledData(base::Pickle(), Clipboard::GetPlainTextFormatType());
 }
 
 TYPED_TEST(ClipboardTest, WriteImageEmptyParams) {
   ScopedClipboardWriter scw(CLIPBOARD_TYPE_COPY_PASTE);
   scw.WriteImage(SkBitmap());
 }
 
 }  // namespace ui