Remove clipboard argument from ScopedClipboardWriter constructor.

ui/base/clipboard/clipboard_unittest.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 "build/build_config.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 63 matching lines @@
 
 bool MarkupMatches(const base::string16& expected_markup,
                    const base::string16& actual_markup) {
   return actual_markup.find(expected_markup) != base::string16::npos;
 }
 
 }  // namespace
 
 TEST_F(ClipboardTest, ClearTest) {
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(ASCIIToUTF16("clear me"));
   }
 
   clipboard().Clear(CLIPBOARD_TYPE_COPY_PASTE);
 
   EXPECT_FALSE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_FALSE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
 }
 
 TEST_F(ClipboardTest, TextTest) {
   base::string16 text(ASCIIToUTF16("This is a base::string16!#$")), text_result;
   std::string ascii_text;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(text);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   clipboard().ReadText(CLIPBOARD_TYPE_COPY_PASTE, &text_result);
 
   EXPECT_EQ(text, text_result);
   clipboard().ReadAsciiText(CLIPBOARD_TYPE_COPY_PASTE, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
 }
 
 TEST_F(ClipboardTest, HTMLTest) {
   base::string16 markup(ASCIIToUTF16("<string>Hi!</string>")), markup_result;
   base::string16 plain(ASCIIToUTF16("Hi!")), plain_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(plain);
     clipboard_writer.WriteHTML(markup, url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   uint32 ignored;
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
                      &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
   // TODO(playmobil): It's not clear that non windows clipboards need to support
   // this.
   EXPECT_EQ(url, url_result);
 #endif  // defined(OS_WIN)
 }
 
 TEST_F(ClipboardTest, RTFTest) {
   std::string rtf =
       "{\\rtf1\\ansi{\\fonttbl\\f0\\fswiss Helvetica;}\\f0\\pard\n"
       "This is some {\\b bold} text.\\par\n"
       "}";
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteRTF(rtf);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetRtfFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   std::string result;
   clipboard().ReadRTF(CLIPBOARD_TYPE_COPY_PASTE, &result);
   EXPECT_EQ(rtf, result);
 }
 
 // TODO(dnicoara) Enable test once Ozone implements clipboard support:
 // crbug.com/361707
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS) && !defined(USE_OZONE)
 TEST_F(ClipboardTest, MultipleBufferTest) {
   base::string16 text(ASCIIToUTF16("Standard")), text_result;
   base::string16 markup(ASCIIToUTF16("<string>Selection</string>"));
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(text);
   }
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_SELECTION);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_SELECTION);
     clipboard_writer.WriteHTML(markup, url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_FALSE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(),
       CLIPBOARD_TYPE_SELECTION));
 
   EXPECT_FALSE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
@@ skipping 15 matching lines @@
 }
 #endif
 
 TEST_F(ClipboardTest, TrickyHTMLTest) {
   base::string16 markup(ASCIIToUTF16("<em>Bye!<!--EndFragment --></em>")),
       markup_result;
   std::string url, url_result;
   base::string16 plain(ASCIIToUTF16("Bye!")), plain_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteText(plain);
     clipboard_writer.WriteHTML(markup, url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   uint32 ignored;
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
                        &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
   // TODO(playmobil): It's not clear that non windows clipboards need to support
   // this.
   EXPECT_EQ(url, url_result);
 #endif  // defined(OS_WIN)
 }
 
 #if defined(OS_WIN)
 TEST_F(ClipboardTest, UniodeHTMLTest) {
   base::string16 markup(UTF8ToUTF16("<div>A \xc3\xb8 \xe6\xb0\xb4</div>")),
       markup_result;
   std::string url, url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteHTML(markup, url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   uint32 fragment_start;
   uint32 fragment_end;
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
                        &fragment_start, &fragment_end);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
   EXPECT_EQ(url, url_result);
   // Make sure that fragment indices were adjusted when converting.
   EXPECT_EQ(36, fragment_start);
   EXPECT_EQ(52, fragment_end);
 }
 #endif  // defined(OS_WIN)
 
 // TODO(estade): Port the following test (decide what target we use for urls)
 #if !defined(OS_POSIX) || defined(OS_MACOSX)
 TEST_F(ClipboardTest, BookmarkTest) {
   base::string16 title(ASCIIToUTF16("The Example Company")), title_result;
   std::string url("http://www.example.com/"), url_result;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteBookmark(title, url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetUrlWFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   clipboard().ReadBookmark(&title_result, &url_result);
   EXPECT_EQ(title, title_result);
   EXPECT_EQ(url, url_result);
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(ClipboardTest, MultiFormatTest) {
   base::string16 text(ASCIIToUTF16("Hi!")), text_result;
   base::string16 markup(ASCIIToUTF16("<strong>Hi!</string>")), markup_result;
   std::string url("http://www.example.com/"), url_result;
   std::string ascii_text;
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteHTML(markup, url);
     clipboard_writer.WriteText(text);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   uint32 ignored;
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &markup_result, &url_result,
                        &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, markup, markup_result);
 #if defined(OS_WIN)
   // TODO(playmobil): It's not clear that non windows clipboards need to support
   // this.
   EXPECT_EQ(url, url_result);
 #endif  // defined(OS_WIN)
   clipboard().ReadText(CLIPBOARD_TYPE_COPY_PASTE, &text_result);
   EXPECT_EQ(text, text_result);
   clipboard().ReadAsciiText(CLIPBOARD_TYPE_COPY_PASTE, &ascii_text);
   EXPECT_EQ(UTF16ToUTF8(text), ascii_text);
 }
 
 TEST_F(ClipboardTest, URLTest) {
   base::string16 url(ASCIIToUTF16("http://www.google.com/"));
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteURL(url);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetPlainTextFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   base::string16 text_result;
   clipboard().ReadText(CLIPBOARD_TYPE_COPY_PASTE, &text_result);
 
@@ skipping 206 matching lines @@
 }
 
 TEST_F(ClipboardTest, DataTest) {
   const ui::Clipboard::FormatType kFormat =
       ui::Clipboard::GetFormatType("chromium/x-test-format");
   std::string payload("test string");
   Pickle write_pickle;
   write_pickle.WriteString(payload);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WritePickledData(write_pickle, kFormat);
   }
 
   ASSERT_TRUE(clipboard().IsFormatAvailable(
       kFormat, CLIPBOARD_TYPE_COPY_PASTE));
   std::string output;
   clipboard().ReadData(kFormat, &output);
   ASSERT_FALSE(output.empty());
 
   Pickle read_pickle(output.data(), output.size());
@@ skipping 10 matching lines @@
   Pickle write_pickle1;
   write_pickle1.WriteString(payload1);
 
   const ui::Clipboard::FormatType kFormat2 =
       ui::Clipboard::GetFormatType("chromium/x-test-format2");
   std::string payload2("test string2");
   Pickle write_pickle2;
   write_pickle2.WriteString(payload2);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
     // overwrite the previous pickle for fun
     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
   }
 
   ASSERT_TRUE(clipboard().IsFormatAvailable(
       kFormat2, CLIPBOARD_TYPE_COPY_PASTE));
 
   // Check string 2.
   std::string output2;
   clipboard().ReadData(kFormat2, &output2);
   ASSERT_FALSE(output2.empty());
 
   Pickle read_pickle2(output2.data(), output2.size());
   PickleIterator iter2(read_pickle2);
   std::string unpickled_string2;
   ASSERT_TRUE(read_pickle2.ReadString(&iter2, &unpickled_string2));
   EXPECT_EQ(payload2, unpickled_string2);
 
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WritePickledData(write_pickle2, kFormat2);
     // overwrite the previous pickle for fun
     clipboard_writer.WritePickledData(write_pickle1, kFormat1);
   }
 
   ASSERT_TRUE(clipboard().IsFormatAvailable(
       kFormat1, CLIPBOARD_TYPE_COPY_PASTE));
 
   // Check string 1.
   std::string output1;
@@ skipping 11 matching lines @@
 TEST_F(ClipboardTest, HyperlinkTest) {
   const std::string kTitle("The <Example> Company's \"home page\"");
   const std::string kUrl("http://www.example.com?x=3&lt=3#\"'<>");
   const std::string kExpectedHtml(
       "<a href=\"http://www.example.com?x=3&amp;lt=3#&quot;&#39;&lt;&gt;\">"
       "The &lt;Example&gt; Company&#39;s &quot;home page&quot;</a>");
 
   std::string url_result;
   base::string16 html_result;
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteHyperlink(ASCIIToUTF16(kTitle), kUrl);
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(Clipboard::GetHtmlFormatType(),
                                             CLIPBOARD_TYPE_COPY_PASTE));
   uint32 ignored;
   clipboard().ReadHTML(CLIPBOARD_TYPE_COPY_PASTE, &html_result, &url_result,
                        &ignored, &ignored);
   EXPECT_PRED2(MarkupMatches, ASCIIToUTF16(kExpectedHtml), html_result);
 }
 #endif
 
 #if defined(OS_WIN)  // Windows only tests.
 TEST_F(ClipboardTest, WebSmartPasteTest) {
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteWebSmartPaste();
   }
 
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetWebKitSmartPasteFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
 }
 
 void HtmlTestHelper(const std::string& cf_html,
                     const std::string& expected_html) {
   std::string html;
@@ skipping 33 matching lines @@
                  "<p>Foo</p>\r\n"
                  "</body>\r\n"
                  "</html>\r\n\r\n",
                  "<p>Foo</p>");
 }
 #endif  // defined(OS_WIN)
 
 // Test writing all formats we have simultaneously.
 TEST_F(ClipboardTest, WriteEverything) {
   {
-    ScopedClipboardWriter writer(&clipboard(), CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter writer(CLIPBOARD_TYPE_COPY_PASTE);
     writer.WriteText(UTF8ToUTF16("foo"));
     writer.WriteURL(UTF8ToUTF16("foo"));
     writer.WriteHTML(UTF8ToUTF16("foo"), "bar");
     writer.WriteBookmark(UTF8ToUTF16("foo"), "bar");
     writer.WriteHyperlink(ASCIIToUTF16("foo"), "bar");
     writer.WriteWebSmartPaste();
     // Left out: WriteFile, WriteFiles, WriteBitmapFromPixels, WritePickledData.
   }
 
   // Passes if we don't crash.
 }
 
 // TODO(dcheng): Fix this test for Android. It's rather involved, since the
 // clipboard change listener is posted to the Java message loop, and spinning
 // that loop from C++ to trigger the callback in the test requires a non-trivial
 // amount of additional work.
 #if !defined(OS_ANDROID)
 // Simple test that the sequence number appears to change when the clipboard is
 // written to.
 // TODO(dcheng): Add a version to test CLIPBOARD_TYPE_SELECTION.
 TEST_F(ClipboardTest, GetSequenceNumber) {
   const uint64 first_sequence_number =
       clipboard().GetSequenceNumber(CLIPBOARD_TYPE_COPY_PASTE);
 
   {
-    ScopedClipboardWriter writer(&clipboard(), CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter writer(CLIPBOARD_TYPE_COPY_PASTE);
     writer.WriteText(UTF8ToUTF16("World"));
   }
 
   // On some platforms, the sequence number is updated by a UI callback so pump
   // the message loop to make sure we get the notification.
   base::RunLoop().RunUntilIdle();
 
   const uint64 second_sequence_number =
       clipboard().GetSequenceNumber(CLIPBOARD_TYPE_COPY_PASTE);
 
   EXPECT_NE(first_sequence_number, second_sequence_number);
 }
 #endif
 
 #if defined(OS_ANDROID)
 
 // Test that if another application writes some text to the pasteboard the
 // clipboard properly invalidates other types.
 TEST_F(ClipboardTest, InternalClipboardInvalidation) {
   // Write a Webkit smart paste tag to our clipboard.
   {
-    ScopedClipboardWriter clipboard_writer(&clipboard(),
-                                           CLIPBOARD_TYPE_COPY_PASTE);
+    ScopedClipboardWriter clipboard_writer(CLIPBOARD_TYPE_COPY_PASTE);
     clipboard_writer.WriteWebSmartPaste();
   }
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetWebKitSmartPasteFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
 
   //
   // Simulate that another application copied something in the Clipboard
   //
   std::string new_value("Some text copied by some other app");
   using base::android::ConvertUTF8ToJavaString;
@@ skipping 41 matching lines @@
   EXPECT_TRUE(clipboard().IsFormatAvailable(
       Clipboard::GetPlainTextWFormatType(), CLIPBOARD_TYPE_COPY_PASTE));
 
   // Make sure the text is what we inserted while simulating the other app
   std::string contents;
   clipboard().ReadAsciiText(CLIPBOARD_TYPE_COPY_PASTE, &contents);
   EXPECT_EQ(contents, new_value);
 }
 #endif
 }  // namespace ui