Change Clipboard::Read*() refs to set dst

- Changed Web-originated clipboard access to set
the destination trying to access the clipboard
data if possible.
- Renamed EndpointType::kVm to kGuestOs

Bug: 1103614
Change-Id: I895ea000e985611896f842274ea6849a822753d8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2346288Reviewed-by: Scott Violet <sky@chromium.org>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Commit-Queue: Aya Elsayed <ayaelattar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#800516}

chrome/browser/renderer_context_menu/render_view_context_menu.cc

@@ -2627,7 +2627,7 @@ bool RenderViewContextMenu::IsPasteEnabled() const {
 
   std::vector<base::string16> types;
   ui::Clipboard::GetForCurrentThread()->ReadAvailableTypes(
-      ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr, &types);
+      ui::ClipboardBuffer::kCopyPaste, CreateDataEndpoint().get(), &types);
   return !types.empty();
 }
 
@@ -2637,7 +2637,7 @@ bool RenderViewContextMenu::IsPasteAndMatchStyleEnabled() const {
 
   return ui::Clipboard::GetForCurrentThread()->IsFormatAvailable(
       ui::ClipboardFormatType::GetPlainTextType(),
-      ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr);
+      ui::ClipboardBuffer::kCopyPaste, CreateDataEndpoint().get());
 }
 
 bool RenderViewContextMenu::IsPrintPreviewEnabled() const {
@@ -2684,7 +2684,7 @@ void RenderViewContextMenu::AppendQRCodeGeneratorItem(bool for_image,
 }
 
 std::unique_ptr<ui::ClipboardDataEndpoint>
-RenderViewContextMenu::CreateDataEndpoint() {
+RenderViewContextMenu::CreateDataEndpoint() const {
   RenderFrameHost* render_frame_host = GetRenderFrameHost();
   if (render_frame_host) {
     return std::make_unique<ui::ClipboardDataEndpoint>(

chrome/browser/renderer_context_menu/render_view_context_menu.h

@@ -199,7 +199,7 @@ class RenderViewContextMenu : public RenderViewContextMenuBase {
   void AppendSharedClipboardItem();
   void AppendQRCodeGeneratorItem(bool for_image, bool draw_icon);
 
-  std::unique_ptr<ui::ClipboardDataEndpoint> CreateDataEndpoint();
+  std::unique_ptr<ui::ClipboardDataEndpoint> CreateDataEndpoint() const;
 
   // Command enabled query functions.
   bool IsReloadEnabled() const;

components/arc/clipboard/arc_clipboard_bridge.cc

@@ -49,9 +49,10 @@ mojom::ClipRepresentationPtr CreateHTML(const ui::Clipboard* clipboard) {
   // Unused. URL is sent from CreatePlainText() by reading it from the Bookmark.
   std::string url;
   uint32_t fragment_start, fragment_end;
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
 
-  clipboard->ReadHTML(ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr,
-                      &markup16, &url, &fragment_start, &fragment_end);
+  clipboard->ReadHTML(ui::ClipboardBuffer::kCopyPaste, &data_dst, &markup16,
+                      &url, &fragment_start, &fragment_end);
 
   std::string text(base::UTF16ToUTF8(
       markup16.substr(fragment_start, fragment_end - fragment_start)));
@@ -70,13 +71,13 @@ mojom::ClipRepresentationPtr CreatePlainText(const ui::Clipboard* clipboard) {
   base::string16 title;
   std::string text;
   std::string mime_type(ui::kMimeTypeText);
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
 
   // Both Bookmark and AsciiText are represented by text/plain. If both are
   // present, only use Bookmark.
-  clipboard->ReadBookmark(/* data_dst = */ nullptr, &title, &text);
+  clipboard->ReadBookmark(&data_dst, &title, &text);
   if (text.size() == 0)
-    clipboard->ReadAsciiText(ui::ClipboardBuffer::kCopyPaste,
-                             /* data_dst = */ nullptr, &text);
+    clipboard->ReadAsciiText(ui::ClipboardBuffer::kCopyPaste, &data_dst, &text);
 
   return mojom::ClipRepresentation::New(mime_type,
                                         mojom::ClipValue::NewText(text));
@@ -86,8 +87,9 @@ mojom::ClipDataPtr GetClipData(const ui::Clipboard* clipboard) {
   DCHECK(clipboard);
 
   std::vector<base::string16> mime_types;
-  clipboard->ReadAvailableTypes(ui::ClipboardBuffer::kCopyPaste,
-                                /* data_dst = */ nullptr, &mime_types);
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
+  clipboard->ReadAvailableTypes(ui::ClipboardBuffer::kCopyPaste, &data_dst,
+                                &mime_types);
 
   mojom::ClipDataPtr clip_data(mojom::ClipData::New());
 
@@ -176,7 +178,7 @@ void ArcClipboardBridge::SetClipContent(mojom::ClipDataPtr clip_data) {
   base::AutoReset<bool> auto_reset(&event_originated_at_instance_, true);
   ui::ScopedClipboardWriter writer(
       ui::ClipboardBuffer::kCopyPaste,
-      std::make_unique<ui::ClipboardDataEndpoint>(ui::EndpointType::kVm));
+      std::make_unique<ui::ClipboardDataEndpoint>(ui::EndpointType::kGuestOs));
 
   for (const auto& repr : clip_data->representations) {
     const std::string& mime_type(repr->mime_type);

components/exo/data_offer.cc

@@ -4,6 +4,8 @@
 
 #include "components/exo/data_offer.h"
 
+#include <memory>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/i18n/icu_string_conversions.h"
@@ -24,6 +26,7 @@
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/clipboard_buffer.h"
 #include "ui/base/clipboard/clipboard_constants.h"
+#include "ui/base/clipboard/clipboard_data_endpoint.h"
 #include "ui/base/dragdrop/file_info/file_info.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "url/gurl.h"
@@ -120,8 +123,9 @@ scoped_refptr<base::RefCountedString> EncodeAsRefCountedString(
 
 void ReadTextFromClipboard(const std::string& charset, base::ScopedFD fd) {
   base::string16 text;
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
   ui::Clipboard::GetForCurrentThread()->ReadText(
-      ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr, &text);
+      ui::ClipboardBuffer::kCopyPaste, &data_dst, &text);
   WriteFileDescriptor(std::move(fd), EncodeAsRefCountedString(text, charset));
 }
 
@@ -129,17 +133,17 @@ void ReadHTMLFromClipboard(const std::string& charset, base::ScopedFD fd) {
   base::string16 text;
   std::string url;
   uint32_t start, end;
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
   ui::Clipboard::GetForCurrentThread()->ReadHTML(
-      ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr, &text, &url,
-      &start, &end);
+      ui::ClipboardBuffer::kCopyPaste, &data_dst, &text, &url, &start, &end);
   WriteFileDescriptor(std::move(fd), EncodeAsRefCountedString(text, charset));
 }
 
 void ReadRTFFromClipboard(base::ScopedFD fd) {
   std::string text;
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
   ui::Clipboard::GetForCurrentThread()->ReadRTF(ui::ClipboardBuffer::kCopyPaste,
-                                                /* data_dst = */ nullptr,
-                                                &text);
+                                                &data_dst, &text);
   WriteFileDescriptor(std::move(fd), base::RefCountedString::TakeString(&text));
 }
 
@@ -164,9 +168,9 @@ void OnReceivePNGFromClipboard(base::ScopedFD fd, const SkBitmap& sk_bitmap) {
 }
 
 void ReadPNGFromClipboard(base::ScopedFD fd) {
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
   ui::Clipboard::GetForCurrentThread()->ReadImage(
-      ui::ClipboardBuffer::kCopyPaste,
-      /* data_dst = */ nullptr,
+      ui::ClipboardBuffer::kCopyPaste, &data_dst,
       base::BindOnce(&OnReceivePNGFromClipboard, std::move(fd)));
 }
 
@@ -314,9 +318,9 @@ void DataOffer::SetDropData(FileHelper* file_helper,
 void DataOffer::SetClipboardData(FileHelper* file_helper,
                                  const ui::Clipboard& data) {
   DCHECK_EQ(0u, data_.size());
+  const ui::ClipboardDataEndpoint data_dst(ui::EndpointType::kGuestOs);
   if (data.IsFormatAvailable(ui::ClipboardFormatType::GetPlainTextType(),
-                             ui::ClipboardBuffer::kCopyPaste,
-                             /* data_dst = */ nullptr)) {
+                             ui::ClipboardBuffer::kCopyPaste, &data_dst)) {
     auto utf8_callback =
         base::BindRepeating(&ReadTextFromClipboard, std::string(kUTF8));
     delegate_->OnOffer(std::string(ui::kMimeTypeTextUtf8));
@@ -330,8 +334,7 @@ void DataOffer::SetClipboardData(FileHelper* file_helper,
         base::BindRepeating(&ReadTextFromClipboard, std::string(kUTF16)));
   }
   if (data.IsFormatAvailable(ui::ClipboardFormatType::GetHtmlType(),
-                             ui::ClipboardBuffer::kCopyPaste,
-                             /* data_dst = */ nullptr)) {
+                             ui::ClipboardBuffer::kCopyPaste, &data_dst)) {
     delegate_->OnOffer(std::string(kTextHtmlMimeTypeUtf8));
     data_callbacks_.emplace(
         std::string(kTextHtmlMimeTypeUtf8),
@@ -342,15 +345,13 @@ void DataOffer::SetClipboardData(FileHelper* file_helper,
         base::BindRepeating(&ReadHTMLFromClipboard, std::string(kUTF16)));
   }
   if (data.IsFormatAvailable(ui::ClipboardFormatType::GetRtfType(),
-                             ui::ClipboardBuffer::kCopyPaste,
-                             /* data_dst = */ nullptr)) {
+                             ui::ClipboardBuffer::kCopyPaste, &data_dst)) {
     delegate_->OnOffer(std::string(kTextRtfMimeType));
     data_callbacks_.emplace(std::string(kTextRtfMimeType),
                             base::BindRepeating(&ReadRTFFromClipboard));
   }
   if (data.IsFormatAvailable(ui::ClipboardFormatType::GetBitmapType(),
-                             ui::ClipboardBuffer::kCopyPaste,
-                             /* data_dst = */ nullptr)) {
+                             ui::ClipboardBuffer::kCopyPaste, &data_dst)) {
     delegate_->OnOffer(std::string(kImagePngMimeType));
     data_callbacks_.emplace(std::string(kImagePngMimeType),
                             base::BindRepeating(&ReadPNGFromClipboard));

components/exo/seat.cc

@@ -138,7 +138,7 @@ class Seat::RefCountedScopedClipboardWriter
   explicit RefCountedScopedClipboardWriter()
       : ScopedClipboardWriter(ui::ClipboardBuffer::kCopyPaste,
                               std::make_unique<ui::ClipboardDataEndpoint>(
-                                  ui::EndpointType::kVm)) {}
+                                  ui::EndpointType::kGuestOs)) {}
 
  private:
   friend class base::RefCounted<RefCountedScopedClipboardWriter>;

components/renderer_context_menu/render_view_context_menu_base.cc

@@ -428,7 +428,7 @@ void RenderViewContextMenuBase::MenuClosed(ui::SimpleMenuModel* source) {
   }
 }
 
-RenderFrameHost* RenderViewContextMenuBase::GetRenderFrameHost() {
+RenderFrameHost* RenderViewContextMenuBase::GetRenderFrameHost() const {
   return RenderFrameHost::FromID(render_process_id_, render_frame_id_);
 }
 

components/renderer_context_menu/render_view_context_menu_base.h

@@ -163,7 +163,7 @@ class RenderViewContextMenuBase : public ui::SimpleMenuModel::Delegate,
   virtual void AppendPlatformEditableItems() {}
 
   // May return nullptr if the frame was deleted while the menu was open.
-  content::RenderFrameHost* GetRenderFrameHost();
+  content::RenderFrameHost* GetRenderFrameHost() const;
 
   bool IsCustomItemChecked(int id) const;
   bool IsCustomItemEnabled(int id) const;

content/browser/frame_host/clipboard_host_impl.cc

@@ -132,7 +132,7 @@ void ClipboardHostImpl::ReadAvailableTypes(
     ui::ClipboardBuffer clipboard_buffer,
     ReadAvailableTypesCallback callback) {
   std::vector<base::string16> types;
-  clipboard_->ReadAvailableTypes(clipboard_buffer, /* data_dst = */ nullptr,
+  clipboard_->ReadAvailableTypes(clipboard_buffer, CreateDataEndpoint().get(),
                                  &types);
   std::move(callback).Run(types);
 }
@@ -141,32 +141,33 @@ void ClipboardHostImpl::IsFormatAvailable(blink::mojom::ClipboardFormat format,
                                           ui::ClipboardBuffer clipboard_buffer,
                                           IsFormatAvailableCallback callback) {
   bool result = false;
+  auto data_endpoint = CreateDataEndpoint();
   switch (format) {
     case blink::mojom::ClipboardFormat::kPlaintext:
       result = clipboard_->IsFormatAvailable(
           ui::ClipboardFormatType::GetPlainTextType(), clipboard_buffer,
-          /* data_dst = */ nullptr);
+          data_endpoint.get());
 #if defined(OS_WIN)
       result |= clipboard_->IsFormatAvailable(
           ui::ClipboardFormatType::GetPlainTextAType(), clipboard_buffer,
-          /* data_dst = */ nullptr);
+          data_endpoint.get());
 #endif
       break;
     case blink::mojom::ClipboardFormat::kHtml:
-      result = clipboard_->IsFormatAvailable(
-          ui::ClipboardFormatType::GetHtmlType(), clipboard_buffer,
-          /* data_dst = */ nullptr);
+      result =
+          clipboard_->IsFormatAvailable(ui::ClipboardFormatType::GetHtmlType(),
+                                        clipboard_buffer, data_endpoint.get());
       break;
     case blink::mojom::ClipboardFormat::kSmartPaste:
       result = clipboard_->IsFormatAvailable(
           ui::ClipboardFormatType::GetWebKitSmartPasteType(), clipboard_buffer,
-          /* data_dst = */ nullptr);
+          data_endpoint.get());
       break;
     case blink::mojom::ClipboardFormat::kBookmark:
 #if defined(OS_WIN) || defined(OS_MAC)
-      result = clipboard_->IsFormatAvailable(
-          ui::ClipboardFormatType::GetUrlType(), clipboard_buffer,
-          /* data_dst = */ nullptr);
+      result =
+          clipboard_->IsFormatAvailable(ui::ClipboardFormatType::GetUrlType(),
+                                        clipboard_buffer, data_endpoint.get());
 #else
       result = false;
 #endif
@@ -178,18 +179,17 @@ void ClipboardHostImpl::IsFormatAvailable(blink::mojom::ClipboardFormat format,
 void ClipboardHostImpl::ReadText(ui::ClipboardBuffer clipboard_buffer,
                                  ReadTextCallback callback) {
   base::string16 result;
+  auto data_dst = CreateDataEndpoint();
   if (clipboard_->IsFormatAvailable(ui::ClipboardFormatType::GetPlainTextType(),
-                                    clipboard_buffer,
-                                    /* data_dst = */ nullptr)) {
-    clipboard_->ReadText(clipboard_buffer, /* data_dst = */ nullptr, &result);
+                                    clipboard_buffer, data_dst.get())) {
+    clipboard_->ReadText(clipboard_buffer, data_dst.get(), &result);
   } else {
 #if defined(OS_WIN)
     if (clipboard_->IsFormatAvailable(
             ui::ClipboardFormatType::GetPlainTextAType(), clipboard_buffer,
-            /* data_dst = */ nullptr)) {
+            data_dst.get())) {
       std::string ascii;
-      clipboard_->ReadAsciiText(clipboard_buffer,
-                                /* data_dst = */ nullptr, &ascii);
+      clipboard_->ReadAsciiText(clipboard_buffer, data_dst.get(), &ascii);
       result = base::ASCIIToUTF16(ascii);
     }
 #endif
@@ -215,8 +215,9 @@ void ClipboardHostImpl::ReadHtml(ui::ClipboardBuffer clipboard_buffer,
   std::string src_url_str;
   uint32_t fragment_start = 0;
   uint32_t fragment_end = 0;
-  clipboard_->ReadHTML(clipboard_buffer, /* data_dst = */ nullptr, &markup,
-                       &src_url_str, &fragment_start, &fragment_end);
+  auto data_dst = CreateDataEndpoint();
+  clipboard_->ReadHTML(clipboard_buffer, data_dst.get(), &markup, &src_url_str,
+                       &fragment_start, &fragment_end);
 
   std::string data = base::UTF16ToUTF8(markup);
   PerformPasteIfAllowed(
@@ -238,7 +239,8 @@ void ClipboardHostImpl::ReadHtml(ui::ClipboardBuffer clipboard_buffer,
 void ClipboardHostImpl::ReadRtf(ui::ClipboardBuffer clipboard_buffer,
                                 ReadRtfCallback callback) {
   std::string result;
-  clipboard_->ReadRTF(clipboard_buffer, /* data_dst = */ nullptr, &result);
+  auto data_dst = CreateDataEndpoint();
+  clipboard_->ReadRTF(clipboard_buffer, data_dst.get(), &result);
 
   std::string data = result;
   PerformPasteIfAllowed(clipboard_->GetSequenceNumber(clipboard_buffer),
@@ -255,8 +257,8 @@ void ClipboardHostImpl::ReadRtf(ui::ClipboardBuffer clipboard_buffer,
 
 void ClipboardHostImpl::ReadImage(ui::ClipboardBuffer clipboard_buffer,
                                   ReadImageCallback callback) {
-  clipboard_->ReadImage(clipboard_buffer,
-                        /* data_dst = */ nullptr,
+  auto data_dst = CreateDataEndpoint();
+  clipboard_->ReadImage(clipboard_buffer, data_dst.get(),
                         base::BindOnce(&ClipboardHostImpl::OnReadImage,
                                        weak_ptr_factory_.GetWeakPtr(),
                                        clipboard_buffer, std::move(callback)));
@@ -285,8 +287,8 @@ void ClipboardHostImpl::ReadCustomData(ui::ClipboardBuffer clipboard_buffer,
                                        const base::string16& type,
                                        ReadCustomDataCallback callback) {
   base::string16 result;
-  clipboard_->ReadCustomData(clipboard_buffer, type, /* data_dst = */ nullptr,
-                             &result);
+  auto data_dst = CreateDataEndpoint();
+  clipboard_->ReadCustomData(clipboard_buffer, type, data_dst.get(), &result);
 
   std::string data = base::UTF16ToUTF8(result);
   PerformPasteIfAllowed(
@@ -333,15 +335,8 @@ void ClipboardHostImpl::WriteImage(const SkBitmap& bitmap) {
 }
 
 void ClipboardHostImpl::CommitWrite() {
-  std::unique_ptr<ui::ClipboardDataEndpoint> data_src;
-  RenderFrameHostImpl* render_frame_host =
-      RenderFrameHostImpl::FromID(render_frame_pid_, render_frame_routing_id_);
-  if (render_frame_host) {
-    data_src = std::make_unique<ui::ClipboardDataEndpoint>(
-        render_frame_host->GetLastCommittedURL());
-  }
   clipboard_writer_ = std::make_unique<ui::ScopedClipboardWriter>(
-      ui::ClipboardBuffer::kCopyPaste, std::move(data_src));
+      ui::ClipboardBuffer::kCopyPaste, CreateDataEndpoint());
 }
 
 void ClipboardHostImpl::PerformPasteIfAllowed(
@@ -398,4 +393,14 @@ void ClipboardHostImpl::CleanupObsoleteRequests() {
   }
 }
 
+std::unique_ptr<ui::ClipboardDataEndpoint>
+ClipboardHostImpl::CreateDataEndpoint() {
+  RenderFrameHostImpl* render_frame_host =
+      RenderFrameHostImpl::FromID(render_frame_pid_, render_frame_routing_id_);
+  if (render_frame_host) {
+    return std::make_unique<ui::ClipboardDataEndpoint>(
+        render_frame_host->GetLastCommittedURL());
+  }
+  return nullptr;
+}
 }  // namespace content

content/browser/frame_host/clipboard_host_impl.h

@@ -175,6 +175,8 @@ class CONTENT_EXPORT ClipboardHostImpl : public blink::mojom::ClipboardHost {
                    ReadImageCallback callback,
                    const SkBitmap& bitmap);
 
+  std::unique_ptr<ui::ClipboardDataEndpoint> CreateDataEndpoint();
+
   mojo::Receiver<blink::mojom::ClipboardHost> receiver_;
   ui::Clipboard* const clipboard_;  // Not owned
   int render_frame_routing_id_;

content/browser/frame_host/raw_clipboard_host_impl.cc

@@ -108,7 +108,8 @@ void RawClipboardHostImpl::ReadAvailableFormatNames(
     return;
   std::vector<base::string16> raw_types =
       clipboard_->ReadAvailablePlatformSpecificFormatNames(
-          ui::ClipboardBuffer::kCopyPaste, /* data_dst = */ nullptr);
+          ui::ClipboardBuffer::kCopyPaste,
+          CreateDataEndpoint(render_frame_host_).get());
   std::move(callback).Run(raw_types);
 }
 
@@ -124,7 +125,7 @@ void RawClipboardHostImpl::Read(const base::string16& format,
   std::string result;
   clipboard_->ReadData(
       ui::ClipboardFormatType::GetType(base::UTF16ToUTF8(format)),
-      /* data_dst = */ nullptr, &result);
+      CreateDataEndpoint(render_frame_host_).get(), &result);
   base::span<const uint8_t> span(
       reinterpret_cast<const uint8_t*>(result.data()), result.size());
   mojo_base::BigBuffer buffer = mojo_base::BigBuffer(span);

ui/base/clipboard/clipboard_data_endpoint.h

@@ -15,9 +15,11 @@ namespace ui {
 // destination trying to read the clipboard data.
 // Whenever a new format is supported, a new enum should be added.
 enum class EndpointType {
-  kUrl = 0,  // Website URL e.g. www.example.com
-  kVm = 1,   // Virtual machine: ARC++, PluginVM, Crostini.
-  kMaxValue = kVm
+#if defined(OS_CHROMEOS) || (OS_LINUX) || (OS_FUCHSIA)
+  kGuestOs = 0,  // Guest OS: ARC++, PluginVM, Crostini.
+#endif
+  kUrl = 1,  // Website URL e.g. www.example.com
+  kMaxValue = kUrl
 };
 
 // ClipboardDataEndpoint can represent: