Use typemap to convert blink::mojom::ClipboardBuffer to ui::ClipboardType.

We removed this typemap when moving the mojom into WebKit, now we add it
back to do the marshaling between ClipboardBuffer and ClipboardType on
the browser side.

As we don't intend at this time to send messages of this type in the
opposite direction we only implement the FromMojom method in
clipboard_struct_traits.

Bug: 775830
Change-Id: Ib3dacbcc5b3c029167e902afbf7c8c5c809f1ee9
Reviewed-on: https://chromium-review.googlesource.com/823542Reviewed-by: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: Daniel Cheng <dcheng@chromium.org>
Commit-Queue: Daniel Cheng <dcheng@chromium.org>
Cr-Commit-Position: refs/heads/master@{#524593}

content/browser/renderer_host/clipboard_host_impl.cc

@@ -4,6 +4,7 @@
 
 #include "content/browser/renderer_host/clipboard_host_impl.h"
 
+#include <limits>
 #include <utility>
 
 #include "base/bind.h"
@@ -68,20 +69,16 @@ ClipboardHostImpl::~ClipboardHostImpl() {
   clipboard_writer_->Reset();
 }
 
-void ClipboardHostImpl::GetSequenceNumber(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::GetSequenceNumber(ui::ClipboardType clipboard_type,
                                           GetSequenceNumberCallback callback) {
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::move(callback).Run(clipboard_->GetSequenceNumber(clipboard_type));
 }
 
 void ClipboardHostImpl::ReadAvailableTypes(
-    blink::mojom::ClipboardBuffer buffer,
+    ui::ClipboardType clipboard_type,
     ReadAvailableTypesCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
   std::vector<base::string16> types;
   bool contains_filenames;
   clipboard_->ReadAvailableTypes(clipboard_type, &types, &contains_filenames);
@@ -89,11 +86,9 @@ void ClipboardHostImpl::ReadAvailableTypes(
 }
 
 void ClipboardHostImpl::IsFormatAvailable(blink::mojom::ClipboardFormat format,
-                                          blink::mojom::ClipboardBuffer buffer,
+                                          ui::ClipboardType clipboard_type,
                                           IsFormatAvailableCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
   bool result = false;
   switch (format) {
     case blink::mojom::ClipboardFormat::kPlaintext:
@@ -122,11 +117,9 @@ void ClipboardHostImpl::IsFormatAvailable(blink::mojom::ClipboardFormat format,
   std::move(callback).Run(result);
 }
 
-void ClipboardHostImpl::ReadText(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::ReadText(ui::ClipboardType clipboard_type,
                                  ReadTextCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
 
   base::string16 result;
   if (clipboard_->IsFormatAvailable(ui::Clipboard::GetPlainTextWFormatType(),
@@ -141,11 +134,9 @@ void ClipboardHostImpl::ReadText(blink::mojom::ClipboardBuffer buffer,
   std::move(callback).Run(result);
 }
 
-void ClipboardHostImpl::ReadHtml(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::ReadHtml(ui::ClipboardType clipboard_type,
                                  ReadHtmlCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
 
   base::string16 markup;
   std::string src_url_str;
@@ -157,22 +148,18 @@ void ClipboardHostImpl::ReadHtml(blink::mojom::ClipboardBuffer buffer,
                           fragment_end);
 }
 
-void ClipboardHostImpl::ReadRtf(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::ReadRtf(ui::ClipboardType clipboard_type,
                                 ReadRtfCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
   std::string result;
   clipboard_->ReadRTF(clipboard_type, &result);
   std::move(callback).Run(result);
 }
 
-void ClipboardHostImpl::ReadImage(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::ReadImage(ui::ClipboardType clipboard_type,
                                   ReadImageCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
 
   SkBitmap bitmap = clipboard_->ReadImage(clipboard_type);
 
@@ -233,39 +220,36 @@ void ClipboardHostImpl::OnReadAndEncodeImageFinished(
   std::move(callback).Run(std::string(), std::string(), -1);
 }
 
-void ClipboardHostImpl::ReadCustomData(blink::mojom::ClipboardBuffer buffer,
+void ClipboardHostImpl::ReadCustomData(ui::ClipboardType clipboard_type,
                                        const base::string16& type,
                                        ReadCustomDataCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  ui::ClipboardType clipboard_type;
-  ConvertBufferType(buffer, &clipboard_type);
 
   base::string16 result;
   clipboard_->ReadCustomData(clipboard_type, type, &result);
   std::move(callback).Run(result);
 }
 
-void ClipboardHostImpl::WriteText(blink::mojom::ClipboardBuffer,
+void ClipboardHostImpl::WriteText(ui::ClipboardType,
                                   const base::string16& text) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   clipboard_writer_->WriteText(text);
 }
 
-void ClipboardHostImpl::WriteHtml(blink::mojom::ClipboardBuffer,
+void ClipboardHostImpl::WriteHtml(ui::ClipboardType,
                                   const base::string16& markup,
                                   const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   clipboard_writer_->WriteHTML(markup, url.spec());
 }
 
-void ClipboardHostImpl::WriteSmartPasteMarker(
-    blink::mojom::ClipboardBuffer buffer) {
+void ClipboardHostImpl::WriteSmartPasteMarker(ui::ClipboardType) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   clipboard_writer_->WriteWebSmartPaste();
 }
 
 void ClipboardHostImpl::WriteCustomData(
-    blink::mojom::ClipboardBuffer,
+    ui::ClipboardType,
     const std::unordered_map<base::string16, base::string16>& data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   base::Pickle pickle;
@@ -274,7 +258,7 @@ void ClipboardHostImpl::WriteCustomData(
       pickle, ui::Clipboard::GetWebCustomDataFormatType());
 }
 
-void ClipboardHostImpl::WriteBookmark(blink::mojom::ClipboardBuffer,
+void ClipboardHostImpl::WriteBookmark(ui::ClipboardType,
                                       const std::string& url,
                                       const base::string16& title) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -282,7 +266,7 @@ void ClipboardHostImpl::WriteBookmark(blink::mojom::ClipboardBuffer,
 }
 
 void ClipboardHostImpl::WriteImage(
-    blink::mojom::ClipboardBuffer,
+    ui::ClipboardType,
     const gfx::Size& size,
     mojo::ScopedSharedBufferHandle shared_buffer_handle) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ -310,7 +294,7 @@ void ClipboardHostImpl::WriteImage(
   clipboard_writer_->WriteImage(bitmap);
 }
 
-void ClipboardHostImpl::CommitWrite(blink::mojom::ClipboardBuffer) {
+void ClipboardHostImpl::CommitWrite(ui::ClipboardType) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   clipboard_writer_.reset(
       new ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE));
@@ -322,22 +306,4 @@ void ClipboardHostImpl::WriteStringToFindPboard(const base::string16& text) {
 }
 #endif
 
-void ClipboardHostImpl::ConvertBufferType(blink::mojom::ClipboardBuffer buffer,
-                                          ui::ClipboardType* result) {
-  *result = ui::CLIPBOARD_TYPE_COPY_PASTE;
-  switch (buffer) {
-    case blink::mojom::ClipboardBuffer::kStandard:
-      break;
-    case blink::mojom::ClipboardBuffer::kSelection:
-#if defined(USE_X11)
-      *result = ui::CLIPBOARD_TYPE_SELECTION;
-      break;
-#else
-      // Chrome OS and non-X11 unix builds do not support
-      // the X selection clipboad.
-      // TODO: remove the need for this case, see http://crbug.com/361753
-      mojo::ReportBadMessage("Cannot use kSelection on non X11 platforms.");
-#endif
-  }
-}
 }  // namespace content

content/browser/renderer_host/clipboard_host_impl.h

@@ -56,44 +56,42 @@ class CONTENT_EXPORT ClipboardHostImpl : public blink::mojom::ClipboardHost {
                                     ReadImageCallback callback);
 
   // content::mojom::ClipboardHost
-  void GetSequenceNumber(blink::mojom::ClipboardBuffer buffer,
+  void GetSequenceNumber(ui::ClipboardType clipboard_type,
                          GetSequenceNumberCallback callback) override;
   void IsFormatAvailable(blink::mojom::ClipboardFormat format,
-                         blink::mojom::ClipboardBuffer buffer,
+                         ui::ClipboardType clipboard_type,
                          IsFormatAvailableCallback callback) override;
-  void ReadAvailableTypes(blink::mojom::ClipboardBuffer buffer,
+  void ReadAvailableTypes(ui::ClipboardType clipboard_type,
                           ReadAvailableTypesCallback callback) override;
-  void ReadText(blink::mojom::ClipboardBuffer buffer,
+  void ReadText(ui::ClipboardType clipboard_type,
                 ReadTextCallback callback) override;
-  void ReadHtml(blink::mojom::ClipboardBuffer buffer,
+  void ReadHtml(ui::ClipboardType clipboard_type,
                 ReadHtmlCallback callback) override;
-  void ReadRtf(blink::mojom::ClipboardBuffer buffer,
+  void ReadRtf(ui::ClipboardType clipboard_type,
                ReadRtfCallback callback) override;
-  void ReadImage(blink::mojom::ClipboardBuffer buffer,
+  void ReadImage(ui::ClipboardType clipboard_type,
                  ReadImageCallback callback) override;
-  void ReadCustomData(blink::mojom::ClipboardBuffer buffer,
+  void ReadCustomData(ui::ClipboardType clipboard_type,
                       const base::string16& type,
                       ReadCustomDataCallback callback) override;
-  void WriteText(blink::mojom::ClipboardBuffer buffer,
+  void WriteText(ui::ClipboardType clipboard_type,
                  const base::string16& text) override;
-  void WriteHtml(blink::mojom::ClipboardBuffer buffer,
+  void WriteHtml(ui::ClipboardType clipboard_type,
                  const base::string16& markup,
                  const GURL& url) override;
-  void WriteSmartPasteMarker(blink::mojom::ClipboardBuffer buffer) override;
+  void WriteSmartPasteMarker(ui::ClipboardType clipboard_type) override;
   void WriteCustomData(
-      blink::mojom::ClipboardBuffer buffer,
+      ui::ClipboardType clipboard_type,
       const std::unordered_map<base::string16, base::string16>& data) override;
-  void WriteBookmark(blink::mojom::ClipboardBuffer buffer,
+  void WriteBookmark(ui::ClipboardType clipboard_type,
                      const std::string& url,
                      const base::string16& title) override;
-  void WriteImage(blink::mojom::ClipboardBuffer buffer,
+  void WriteImage(ui::ClipboardType clipboard_type,
                   const gfx::Size& size_in_pixels,
                   mojo::ScopedSharedBufferHandle shared_buffer_handle) override;
-  void CommitWrite(blink::mojom::ClipboardBuffer buffer) override;
+  void CommitWrite(ui::ClipboardType clipboard_type) override;
   void WriteStringToFindPboard(const base::string16& text) override;
 
-  void ConvertBufferType(blink::mojom::ClipboardBuffer, ui::ClipboardType*);
-
   ui::Clipboard* clipboard_;  // Not owned
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   std::unique_ptr<ui::ScopedClipboardWriter> clipboard_writer_;

content/browser/renderer_host/clipboard_host_impl_unittest.cc

@@ -35,12 +35,12 @@ class ClipboardHostImplTest : public ::testing::Test {
                       mojo::ScopedSharedBufferHandle shared_memory,
                       size_t shared_memory_size) {
     host_->WriteImage(
-        blink::mojom::ClipboardBuffer::kStandard, size,
+        ui::CLIPBOARD_TYPE_COPY_PASTE, size,
         shared_memory->Clone(mojo::SharedBufferHandle::AccessMode::READ_ONLY));
   }
 
   void CallCommitWrite() {
-    host_->CommitWrite(blink::mojom::ClipboardBuffer::kStandard);
+    host_->CommitWrite(ui::CLIPBOARD_TYPE_COPY_PASTE);
     base::RunLoop().RunUntilIdle();
   }
 

ui/base/mojo/DEPS

 include_rules = [
   "+mojo/public/cpp/bindings",
+  "+third_party/WebKit/common/clipboard/clipboard.mojom-shared.h"
 ]

ui/base/mojo/clipboard.typemap

+# Copyright 2017 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.
+
+mojom = "//third_party/WebKit/common/clipboard/clipboard.mojom"
+public_headers = [ "//ui/base/clipboard/clipboard_types.h" ]
+traits_headers = [ "//ui/base/mojo/clipboard_struct_traits.h" ]
+deps = [
+  "//ui/base",
+]
+type_mappings = [ "blink.mojom.ClipboardBuffer=ui::ClipboardType" ]

ui/base/mojo/clipboard_struct_traits.h

+// Copyright 2017 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.
+
+#ifndef UI_BASE_MOJO_CLIPBOARD_STRUCT_TRAITS_H_
+#define UI_BASE_MOJO_CLIPBOARD_STRUCT_TRAITS_H_
+
+#include "third_party/WebKit/common/clipboard/clipboard.mojom-shared.h"
+#include "ui/base/clipboard/clipboard_types.h"
+
+namespace mojo {
+
+template <>
+struct EnumTraits<blink::mojom::ClipboardBuffer, ui::ClipboardType> {
+  static blink::mojom::ClipboardBuffer ToMojom(ui::ClipboardType) {
+    // We never intend on converting from ui::Clipboardtype to
+    // blink::mojom::ClipboardBuffer.
+    NOTREACHED();
+    return blink::mojom::ClipboardBuffer::kStandard;
+  }
+
+  static bool FromMojom(blink::mojom::ClipboardBuffer clipboard_type,
+                        ui::ClipboardType* out) {
+    switch (clipboard_type) {
+      case blink::mojom::ClipboardBuffer::kStandard:
+        *out = ui::CLIPBOARD_TYPE_COPY_PASTE;
+        return true;
+      case blink::mojom::ClipboardBuffer::kSelection:
+#if defined(USE_X11)
+        *out = ui::CLIPBOARD_TYPE_SELECTION;
+        return true;
+#else
+        return false;
+#endif
+    }
+    return false;
+  }
+};
+
+}  // namespace mojo
+
+#endif  // UI_BASE_MOJO_CLIPBOARD_STRUCT_TRAITS_H_

ui/base/mojo/typemaps.gni

@@ -3,6 +3,7 @@
 # found in the LICENSE file.
 
 typemaps = [
+  "//ui/base/mojo/clipboard.typemap",
   "//ui/base/mojo/ui_base_types.typemap",
   "//ui/base/mojo/window_open_disposition.typemap",
 ]