diff --git a/blink/renderer/bindings/generated_in_modules.gni b/blink/renderer/bindings/generated_in_modules.gni
index 173262dbd53c..938b099d2a1f 100644
--- a/blink/renderer/bindings/generated_in_modules.gni
+++ b/blink/renderer/bindings/generated_in_modules.gni
@@ -227,8 +227,6 @@ generated_dictionary_sources_in_modules = [
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_channel_splitter_options.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_client_query_options.cc",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_client_query_options.h",
-  "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_clipboard_item_options.cc",
-  "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_clipboard_item_options.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_clipboard_permission_descriptor.cc",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_clipboard_permission_descriptor.h",
   "$root_gen_dir/third_party/blink/renderer/bindings/modules/v8/v8_close_event_init.cc",
diff --git a/blink/renderer/bindings/idl_in_modules.gni b/blink/renderer/bindings/idl_in_modules.gni
index 04e31813d634..66e021717ccc 100644
--- a/blink/renderer/bindings/idl_in_modules.gni
+++ b/blink/renderer/bindings/idl_in_modules.gni
@@ -107,7 +107,6 @@ static_idl_files_in_modules = get_path_info(
           "//third_party/blink/renderer/modules/canvas/offscreencanvas2d/offscreen_canvas_rendering_context_2d.idl",
           "//third_party/blink/renderer/modules/clipboard/clipboard.idl",
           "//third_party/blink/renderer/modules/clipboard/clipboard_item.idl",
-          "//third_party/blink/renderer/modules/clipboard/clipboard_item_options.idl",
           "//third_party/blink/renderer/modules/clipboard/navigator_clipboard.idl",
           "//third_party/blink/renderer/modules/compression/compression_stream.idl",
           "//third_party/blink/renderer/modules/compression/decompression_stream.idl",
diff --git a/blink/renderer/core/testing/mock_clipboard_host.cc b/blink/renderer/core/testing/mock_clipboard_host.cc
index 0f0b30abfd67..96b43043bf19 100644
--- a/blink/renderer/core/testing/mock_clipboard_host.cc
+++ b/blink/renderer/core/testing/mock_clipboard_host.cc
@@ -10,6 +10,7 @@
 #include "third_party/blink/public/common/tokens/tokens.h"
 #include "third_party/blink/renderer/platform/graphics/color_behavior.h"
 #include "third_party/blink/renderer/platform/image-encoders/image_encoder.h"
+#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace blink {
@@ -40,9 +41,7 @@ void MockClipboardHost::GetSequenceNumber(
   std::move(callback).Run(sequence_number_);
 }
 
-void MockClipboardHost::ReadAvailableTypes(
-    mojom::ClipboardBuffer clipboard_buffer,
-    ReadAvailableTypesCallback callback) {
+Vector<String> MockClipboardHost::ReadStandardFormatNames() {
   Vector<String> types;
   if (!plain_text_.IsEmpty())
     types.push_back("text/plain");
@@ -56,7 +55,14 @@ void MockClipboardHost::ReadAvailableTypes(
     CHECK(!base::Contains(types, it.key));
     types.push_back(it.key);
   }
-  std::move(callback).Run(types);
+  return types;
+}
+
+void MockClipboardHost::ReadAvailableTypes(
+    mojom::ClipboardBuffer clipboard_buffer,
+    ReadAvailableTypesCallback callback) {
+  Vector<String> types = ReadStandardFormatNames();
+  std::move(callback).Run(std::move(types));
 }
 
 void MockClipboardHost::IsFormatAvailable(
@@ -173,10 +179,10 @@ void MockClipboardHost::CommitWrite() {
 
 void MockClipboardHost::ReadAvailableCustomAndStandardFormats(
     ReadAvailableCustomAndStandardFormatsCallback callback) {
-  Vector<String> format_names;
+  Vector<String> format_names = ReadStandardFormatNames();
   for (const auto& item : unsanitized_custom_data_map_)
     format_names.emplace_back(item.key);
-  std::move(callback).Run(format_names);
+  std::move(callback).Run(std::move(format_names));
 }
 
 void MockClipboardHost::ReadUnsanitizedCustomFormat(
@@ -199,7 +205,9 @@ void MockClipboardHost::WriteUnsanitizedCustomFormat(
   // Simulate the underlying platform copying this data.
   Vector<uint8_t> data_copy(base::saturated_cast<wtf_size_t>(data.size()),
                             *data.data());
-  unsanitized_custom_data_map_.Set(format, data_copy);
+  // Append the "web " prefix since it is removed by the clipboard writer during
+  // write.
+  unsanitized_custom_data_map_.Set("web " + format, std::move(data_copy));
 }
 
 #if BUILDFLAG(IS_MAC)
diff --git a/blink/renderer/core/testing/mock_clipboard_host.h b/blink/renderer/core/testing/mock_clipboard_host.h
index 73d3fac44cbf..74ac69d20546 100644
--- a/blink/renderer/core/testing/mock_clipboard_host.h
+++ b/blink/renderer/core/testing/mock_clipboard_host.h
@@ -67,6 +67,7 @@ class MockClipboardHost : public mojom::blink::ClipboardHost {
 #if BUILDFLAG(IS_MAC)
   void WriteStringToFindPboard(const String& text) override;
 #endif
+  Vector<String> ReadStandardFormatNames();
 
   mojo::ReceiverSet<mojom::blink::ClipboardHost> receivers_;
   ClipboardSequenceNumberToken sequence_number_;
diff --git a/blink/renderer/modules/clipboard/DEPS b/blink/renderer/modules/clipboard/DEPS
index d6391a348599..4dc7b35d1024 100644
--- a/blink/renderer/modules/clipboard/DEPS
+++ b/blink/renderer/modules/clipboard/DEPS
@@ -1,5 +1,6 @@
 include_rules = [
     "+mojo/public/cpp/base/big_buffer.h",
+    "+net/base/mime_util.h",
     "+third_party/blink/renderer/core/clipboard",
     "-third_party/blink/renderer/modules",
     "+third_party/blink/renderer/modules/event_modules.h",
diff --git a/blink/renderer/modules/clipboard/clipboard.cc b/blink/renderer/modules/clipboard/clipboard.cc
index f08ebfcd1b76..50175b125973 100644
--- a/blink/renderer/modules/clipboard/clipboard.cc
+++ b/blink/renderer/modules/clipboard/clipboard.cc
@@ -6,11 +6,11 @@
 
 #include <utility>
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_clipboard_item_options.h"
 #include "third_party/blink/renderer/core/event_target_names.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/frame/navigator.h"
 #include "third_party/blink/renderer/modules/clipboard/clipboard_promise.h"
+#include "ui/base/clipboard/clipboard_constants.h"
 
 namespace blink {
 
@@ -29,13 +29,7 @@ Clipboard* Clipboard::clipboard(Navigator& navigator) {
 Clipboard::Clipboard(Navigator& navigator) : Supplement<Navigator>(navigator) {}
 
 ScriptPromise Clipboard::read(ScriptState* script_state) {
-  return read(script_state, ClipboardItemOptions::Create());
-}
-
-ScriptPromise Clipboard::read(ScriptState* script_state,
-                              ClipboardItemOptions* options) {
-  return ClipboardPromise::CreateForRead(GetExecutionContext(), script_state,
-                                         options);
+  return ClipboardPromise::CreateForRead(GetExecutionContext(), script_state);
 }
 
 ScriptPromise Clipboard::readText(ScriptState* script_state) {
@@ -63,6 +57,16 @@ ExecutionContext* Clipboard::GetExecutionContext() const {
   return GetSupplementable()->DomWindow();
 }
 
+// static
+String Clipboard::ParseWebCustomFormat(const String& format) {
+  String web_custom_format;
+  if (format.StartsWith(ui::kWebClipboardFormatPrefix)) {
+    web_custom_format = format.Substring(
+        static_cast<unsigned>(std::strlen(ui::kWebClipboardFormatPrefix)));
+  }
+  return web_custom_format;
+}
+
 void Clipboard::Trace(Visitor* visitor) const {
   EventTargetWithInlineData::Trace(visitor);
   Supplement<Navigator>::Trace(visitor);
diff --git a/blink/renderer/modules/clipboard/clipboard.h b/blink/renderer/modules/clipboard/clipboard.h
index 8e2d168b8bba..8b66d4585361 100644
--- a/blink/renderer/modules/clipboard/clipboard.h
+++ b/blink/renderer/modules/clipboard/clipboard.h
@@ -13,7 +13,6 @@
 
 namespace blink {
 
-class ClipboardItemOptions;
 class Navigator;
 class ScriptState;
 
@@ -30,7 +29,6 @@ class Clipboard : public EventTargetWithInlineData,
   Clipboard& operator=(const Clipboard&) = delete;
 
   ScriptPromise read(ScriptState*);
-  ScriptPromise read(ScriptState*, ClipboardItemOptions*);
   ScriptPromise readText(ScriptState*);
 
   ScriptPromise write(ScriptState*, const HeapVector<Member<ClipboardItem>>&);
@@ -40,6 +38,8 @@ class Clipboard : public EventTargetWithInlineData,
   const AtomicString& InterfaceName() const override;
   ExecutionContext* GetExecutionContext() const override;
 
+  static String ParseWebCustomFormat(const String& format);
+
   void Trace(Visitor*) const override;
 };
 
diff --git a/blink/renderer/modules/clipboard/clipboard.idl b/blink/renderer/modules/clipboard/clipboard.idl
index 01d0dac998d4..0f90bb027560 100644
--- a/blink/renderer/modules/clipboard/clipboard.idl
+++ b/blink/renderer/modules/clipboard/clipboard.idl
@@ -12,11 +12,6 @@
      CallWith=ScriptState
     ] Promise<sequence<ClipboardItem>> read();
 
-    [MeasureAs=AsyncClipboardAPIRead,
-     CallWith=ScriptState,
-     RuntimeEnabled=ClipboardCustomFormats
-    ] Promise<sequence<ClipboardItem>> read(ClipboardItemOptions options);
-
     [MeasureAs=AsyncClipboardAPIReadText,
      CallWith=ScriptState
     ] Promise<DOMString> readText();
diff --git a/blink/renderer/modules/clipboard/clipboard_item.cc b/blink/renderer/modules/clipboard/clipboard_item.cc
index cac082816898..9c94308e4b04 100644
--- a/blink/renderer/modules/clipboard/clipboard_item.cc
+++ b/blink/renderer/modules/clipboard/clipboard_item.cc
@@ -4,21 +4,22 @@
 
 #include "third_party/blink/renderer/modules/clipboard/clipboard_item.h"
 
+#include "net/base/mime_util.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_clipboard_item_options.h"
 #include "third_party/blink/renderer/core/dom/dom_exception.h"
+#include "third_party/blink/renderer/modules/clipboard/clipboard.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
+#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
+#include "ui/base/clipboard/clipboard_constants.h"
 
 namespace blink {
 
 // static
 ClipboardItem* ClipboardItem::Create(
     const HeapVector<std::pair<String, ScriptPromise>>& items,
-    const ClipboardItemOptions* options,
     ExceptionState& exception_state) {
-  DCHECK(options);
   // Check that incoming dictionary isn't empty. If it is, it's possible that
   // Javascript bindings implicitly converted an Object (like a ScriptPromise)
   // into {}, an empty dictionary.
@@ -26,18 +27,38 @@ ClipboardItem* ClipboardItem::Create(
     exception_state.ThrowTypeError("Empty dictionary argument");
     return nullptr;
   }
-  return MakeGarbageCollected<ClipboardItem>(items, options);
+  return MakeGarbageCollected<ClipboardItem>(items);
 }
 
 ClipboardItem::ClipboardItem(
-    const HeapVector<std::pair<String, ScriptPromise>>& items,
-    const ClipboardItemOptions* options)
-    : items_(items) {
-  DCHECK(items_.size());
-  if (options->hasUnsanitized()) {
-    for (const auto& unsanitized_item : options->unsanitized()) {
-      custom_format_items_.push_back(unsanitized_item);
+    const HeapVector<std::pair<String, ScriptPromise>>& items) {
+  DCHECK(items.size());
+  for (const auto& item : items) {
+    String web_custom_format = Clipboard::ParseWebCustomFormat(item.first);
+    if (!web_custom_format.IsEmpty()) {
+      // Types with "web " prefix are special, so we do some level of MIME type
+      // parsing here to get a valid web custom format type.
+      // We want to ensure that the string after removing the "web " prefix is
+      // a valid MIME type.
+      // e.g. "web text/html" is a web custom MIME type & "text/html" is a
+      // well-known MIME type. Removing the "web " prefix makes it hard to
+      // differentiate between the two.
+      std::string web_top_level_mime_type;
+      std::string web_mime_sub_type;
+      if (net::ParseMimeTypeWithoutParameter(web_custom_format.Utf8(),
+                                             &web_top_level_mime_type,
+                                             &web_mime_sub_type)) {
+        String web_custom_format_string = String::Format(
+            "%s%s/%s", ui::kWebClipboardFormatPrefix,
+            web_top_level_mime_type.c_str(), web_mime_sub_type.c_str());
+        items_.emplace_back(web_custom_format_string, item.second);
+        custom_format_items_.push_back(web_custom_format_string);
+        continue;
+      }
     }
+    // Any arbitrary type can be added to ClipboardItem, but there may not be
+    // any read/write support for that type.
+    items_.push_back(item);
   }
 }
 
@@ -54,9 +75,8 @@ ScriptPromise ClipboardItem::getType(ScriptState* script_state,
                                      const String& type,
                                      ExceptionState& exception_state) const {
   for (const auto& item : items_) {
-    if (type == item.first) {
+    if (type == item.first)
       return item.second;
-    }
   }
 
   exception_state.ThrowDOMException(DOMExceptionCode::kNotFoundError,
diff --git a/blink/renderer/modules/clipboard/clipboard_item.h b/blink/renderer/modules/clipboard/clipboard_item.h
index c665606a8bb6..a4fc528c080f 100644
--- a/blink/renderer/modules/clipboard/clipboard_item.h
+++ b/blink/renderer/modules/clipboard/clipboard_item.h
@@ -12,7 +12,6 @@
 namespace blink {
 
 class ScriptState;
-class ClipboardItemOptions;
 
 class ClipboardItem final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
@@ -20,12 +19,10 @@ class ClipboardItem final : public ScriptWrappable {
  public:
   static ClipboardItem* Create(
       const HeapVector<std::pair<String, ScriptPromise>>& items,
-      const ClipboardItemOptions* options,
       ExceptionState& exception_state);
 
   explicit ClipboardItem(
-      const HeapVector<std::pair<String, ScriptPromise>>& items,
-      const ClipboardItemOptions* options);
+      const HeapVector<std::pair<String, ScriptPromise>>& items);
   Vector<String> types() const;
   ScriptPromise getType(ScriptState* script_state,
                         const String& type,
@@ -35,7 +32,7 @@ class ClipboardItem final : public ScriptWrappable {
     return items_;
   }
 
-  // Returns the custom formats passed to direct option.
+  // Returns the custom formats that have a "web " prefix.
   const Vector<String>& CustomFormats() const { return custom_format_items_; }
 
   void Trace(Visitor*) const override;
diff --git a/blink/renderer/modules/clipboard/clipboard_item.idl b/blink/renderer/modules/clipboard/clipboard_item.idl
index 3a8a2664339b..9a5029084e76 100644
--- a/blink/renderer/modules/clipboard/clipboard_item.idl
+++ b/blink/renderer/modules/clipboard/clipboard_item.idl
@@ -8,8 +8,7 @@
   SecureContext,
   Exposed=Window
 ] interface ClipboardItem {
-  [RaisesException] constructor(record<DOMString, Promise<Blob>> items,
-              optional ClipboardItemOptions options = {});
+  [RaisesException] constructor(record<DOMString, Promise<Blob>> items);
   readonly attribute FrozenArray<DOMString> types;
 
   [
diff --git a/blink/renderer/modules/clipboard/clipboard_item_options.idl b/blink/renderer/modules/clipboard/clipboard_item_options.idl
deleted file mode 100644
index c1e12134f667..000000000000
--- a/blink/renderer/modules/clipboard/clipboard_item_options.idl
+++ /dev/null
@@ -1,9 +0,0 @@
-// Copyright 2019 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.
-
-// https://w3c.github.io/clipboard-apis/#clipboard-interface
-
-dictionary ClipboardItemOptions {
-  [RuntimeEnabled=ClipboardCustomFormats] sequence<DOMString> unsanitized;
-};
\ No newline at end of file
diff --git a/blink/renderer/modules/clipboard/clipboard_promise.cc b/blink/renderer/modules/clipboard/clipboard_promise.cc
index 307e408b319a..d398e4ba09f4 100644
--- a/blink/renderer/modules/clipboard/clipboard_promise.cc
+++ b/blink/renderer/modules/clipboard/clipboard_promise.cc
@@ -15,7 +15,6 @@
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_function.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_promise_resolver.h"
-#include "third_party/blink/renderer/bindings/modules/v8/v8_clipboard_item_options.h"
 #include "third_party/blink/renderer/core/clipboard/clipboard_mime_types.h"
 #include "third_party/blink/renderer/core/clipboard/system_clipboard.h"
 #include "third_party/blink/renderer/core/dom/document.h"
@@ -115,16 +114,14 @@ class ClipboardPromise::BlobPromiseResolverFunction final
 
 // static
 ScriptPromise ClipboardPromise::CreateForRead(ExecutionContext* context,
-                                              ScriptState* script_state,
-                                              ClipboardItemOptions* options) {
+                                              ScriptState* script_state) {
   if (!script_state->ContextIsValid())
     return ScriptPromise();
   ClipboardPromise* clipboard_promise =
       MakeGarbageCollected<ClipboardPromise>(context, script_state);
   clipboard_promise->GetTaskRunner()->PostTask(
-      FROM_HERE,
-      WTF::Bind(&ClipboardPromise::HandleRead,
-                WrapPersistent(clipboard_promise), WrapPersistent(options)));
+      FROM_HERE, WTF::Bind(&ClipboardPromise::HandleRead,
+                           WrapPersistent(clipboard_promise)));
   return clipboard_promise->script_promise_resolver_->Promise();
 }
 
@@ -215,22 +212,10 @@ void ClipboardPromise::WriteNextRepresentation() {
   wtf_size_t item_index = custom_format_items_.Find(type);
   if (item_index != kNotFound) {
     clipboard_writer_ =
-        ClipboardWriter::Create(local_frame->GetSystemClipboard(), type, this,
-                                /*is_custom_format_type*/ true);
-    if (ClipboardWriter::IsValidType(type, /*is_custom_format_type*/ false)) {
-      // Decrement `clipboard_representation_index_` & remove the format from
-      // the `custom_format_items_` so we can redo the write, but this time, it
-      // will write a sanitized version of the format using the "standard"
-      // format writer. Standard formats include text/html, text/plain,
-      // text/rtf, image/png, text/uri-list & image/svg+xml.
-      // https://github.com/w3c/editing/blob/gh-pages/docs/clipboard-pickling/explainer.md#pickled-version-for-sanitized-formats
-      custom_format_items_.EraseAt(item_index);
-      clipboard_representation_index_--;
-    }
+        ClipboardWriter::Create(local_frame->GetSystemClipboard(), type, this);
   } else {
     clipboard_writer_ =
-        ClipboardWriter::Create(local_frame->GetSystemClipboard(), type, this,
-                                /*is_custom_format_type*/ false);
+        ClipboardWriter::Create(local_frame->GetSystemClipboard(), type, this);
   }
   clipboard_writer_->WriteToSystem(blob);
 }
@@ -245,22 +230,19 @@ void ClipboardPromise::RejectFromReadOrDecodeFailure() {
           clipboard_item_data_[clipboard_representation_index_].first + "."));
 }
 
-void ClipboardPromise::HandleRead(ClipboardItemOptions* options) {
+void ClipboardPromise::HandleRead() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  if (options->hasUnsanitized()) {
-    for (const auto& unsanitized_item : options->unsanitized()) {
-      custom_format_items_.push_back(unsanitized_item);
-    }
-  }
   RequestPermission(mojom::blink::PermissionName::CLIPBOARD_READ,
-                    !custom_format_items_.IsEmpty(),
+                    /*allow_without_sanitization=*/
+                    RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled(),
                     WTF::Bind(&ClipboardPromise::HandleReadWithPermission,
                               WrapPersistent(this)));
 }
 
 void ClipboardPromise::HandleReadText() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  RequestPermission(mojom::blink::PermissionName::CLIPBOARD_READ, false,
+  RequestPermission(mojom::blink::PermissionName::CLIPBOARD_READ,
+                    /*allow_without_sanitization=*/false,
                     WTF::Bind(&ClipboardPromise::HandleReadTextWithPermission,
                               WrapPersistent(this)));
 }
@@ -299,16 +281,18 @@ void ClipboardPromise::HandleWrite(
   DCHECK(RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() ||
          custom_format_items_.IsEmpty());
 
-  RequestPermission(mojom::blink::PermissionName::CLIPBOARD_WRITE,
-                    !custom_format_items_.IsEmpty(),
-                    WTF::Bind(&ClipboardPromise::HandleWriteWithPermission,
-                              WrapPersistent(this)));
+  RequestPermission(
+      mojom::blink::PermissionName::CLIPBOARD_WRITE,
+      /*allow_without_sanitization=*/!custom_format_items_.IsEmpty(),
+      WTF::Bind(&ClipboardPromise::HandleWriteWithPermission,
+                WrapPersistent(this)));
 }
 
 void ClipboardPromise::HandleWriteText(const String& data) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   plain_text_ = data;
-  RequestPermission(mojom::blink::PermissionName::CLIPBOARD_WRITE, false,
+  RequestPermission(mojom::blink::PermissionName::CLIPBOARD_WRITE,
+                    /*allow_without_sanitization=*/false,
                     WTF::Bind(&ClipboardPromise::HandleWriteTextWithPermission,
                               WrapPersistent(this)));
 }
@@ -324,7 +308,7 @@ void ClipboardPromise::HandleReadWithPermission(PermissionStatus status) {
   }
 
   SystemClipboard* system_clipboard = GetLocalFrame()->GetSystemClipboard();
-  if (!custom_format_items_.IsEmpty()) {
+  if (RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled()) {
     system_clipboard->ReadAvailableCustomAndStandardFormats(WTF::Bind(
         &ClipboardPromise::OnReadAvailableFormatNames, WrapPersistent(this)));
     return;
@@ -343,9 +327,6 @@ void ClipboardPromise::ResolveRead() {
     return;
   }
 
-  ClipboardItemOptions* options = ClipboardItemOptions::Create();
-  options->setUnsanitized(custom_format_items_);
-
   ScriptState::Scope scope(script_state_);
   HeapVector<std::pair<String, ScriptPromise>> items;
   items.ReserveInitialCapacity(clipboard_item_data_.size());
@@ -356,7 +337,7 @@ void ClipboardPromise::ResolveRead() {
     items.emplace_back(item.first, promise);
   }
   HeapVector<Member<ClipboardItem>> clipboard_items = {
-      MakeGarbageCollected<ClipboardItem>(items, options)};
+      MakeGarbageCollected<ClipboardItem>(items)};
   script_promise_resolver_->Resolve(clipboard_items);
 }
 
@@ -368,8 +349,7 @@ void ClipboardPromise::OnReadAvailableFormatNames(
 
   clipboard_item_data_.ReserveInitialCapacity(format_names.size());
   for (const String& format_name : format_names) {
-    if (ClipboardWriter::IsValidType(
-            format_name, base::Contains(custom_format_items_, format_name))) {
+    if (ClipboardWriter::IsValidType(format_name)) {
       clipboard_item_data_.emplace_back(format_name,
                                         /* Placeholder value. */ nullptr);
     }
@@ -390,8 +370,7 @@ void ClipboardPromise::ReadNextRepresentation() {
       clipboard_item_data_[clipboard_representation_index_].first;
 
   ClipboardReader* clipboard_reader = ClipboardReader::Create(
-      GetLocalFrame()->GetSystemClipboard(), format_name, this,
-      base::Contains(custom_format_items_, format_name));
+      GetLocalFrame()->GetSystemClipboard(), format_name, this);
   if (!clipboard_reader) {
     OnRead(nullptr);
     return;
@@ -469,8 +448,7 @@ void ClipboardPromise::HandleWriteWithPermission(PermissionStatus status) {
     const String& type = type_and_promise_to_blob.first;
     clipboard_item_types_.emplace_back(type);
     promise_list.emplace_back(type_and_promise_to_blob.second);
-    bool is_valid_custom_format = base::Contains(custom_format_items_, type);
-    if (!ClipboardWriter::IsValidType(type, is_valid_custom_format)) {
+    if (!ClipboardWriter::IsValidType(type)) {
       script_promise_resolver_->Reject(MakeGarbageCollected<DOMException>(
           DOMExceptionCode::kNotAllowedError,
           "Type " + type + " not supported on write."));
@@ -559,7 +537,8 @@ void ClipboardPromise::RequestPermission(
       LocalFrame::HasTransientUserActivation(GetLocalFrame());
   base::UmaHistogramBoolean("Blink.Clipboard.HasTransientUserActivation",
                             has_transient_user_activation);
-  if (!custom_format_items_.IsEmpty() && !has_transient_user_activation) {
+  if (RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() &&
+      !has_transient_user_activation) {
     script_promise_resolver_->Reject(MakeGarbageCollected<DOMException>(
         DOMExceptionCode::kSecurityError,
         "Must be handling a user gesture to use custom clipboard"));
@@ -586,7 +565,8 @@ void ClipboardPromise::RequestPermission(
   // Check permission, and query if necessary.
   // See crbug.com/795929 for moving this check into the Browser process.
   permission_service_->RequestPermission(std::move(permission_descriptor),
-                                         false, std::move(callback));
+                                         /*user_gesture*/ false,
+                                         std::move(callback));
 }
 
 LocalFrame* ClipboardPromise::GetLocalFrame() const {
diff --git a/blink/renderer/modules/clipboard/clipboard_promise.h b/blink/renderer/modules/clipboard/clipboard_promise.h
index 28c51842d25e..ceee63ad6239 100644
--- a/blink/renderer/modules/clipboard/clipboard_promise.h
+++ b/blink/renderer/modules/clipboard/clipboard_promise.h
@@ -31,9 +31,7 @@ class ClipboardPromise final : public GarbageCollected<ClipboardPromise>,
                                public ExecutionContextLifecycleObserver {
  public:
   // Creates promise to execute Clipboard API functions off the main thread.
-  static ScriptPromise CreateForRead(ExecutionContext*,
-                                     ScriptState*,
-                                     ClipboardItemOptions*);
+  static ScriptPromise CreateForRead(ExecutionContext*, ScriptState*);
   static ScriptPromise CreateForReadText(ExecutionContext*, ScriptState*);
   static ScriptPromise CreateForWrite(ExecutionContext*,
                                       ScriptState*,
@@ -70,7 +68,7 @@ class ClipboardPromise final : public GarbageCollected<ClipboardPromise>,
   void WriteNextRepresentation();
 
   // Checks Read/Write permission (interacting with PermissionService).
-  void HandleRead(ClipboardItemOptions*);
+  void HandleRead();
   void HandleReadText();
   void HandleWrite(HeapVector<Member<ClipboardItem>>*);
   void HandleWriteText(const String&);
diff --git a/blink/renderer/modules/clipboard/clipboard_reader.cc b/blink/renderer/modules/clipboard/clipboard_reader.cc
index c37ee70d5723..19a3a84c83a8 100644
--- a/blink/renderer/modules/clipboard/clipboard_reader.cc
+++ b/blink/renderer/modules/clipboard/clipboard_reader.cc
@@ -12,6 +12,7 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/web_feature.h"
 #include "third_party/blink/renderer/core/imagebitmap/image_bitmap.h"
+#include "third_party/blink/renderer/modules/clipboard/clipboard.h"
 #include "third_party/blink/renderer/modules/clipboard/clipboard_promise.h"
 #include "third_party/blink/renderer/modules/clipboard/clipboard_writer.h"
 #include "third_party/blink/renderer/platform/image-encoders/image_encoder.h"
@@ -305,12 +306,14 @@ class ClipboardCustomFormatReader final : public ClipboardReader {
 // static
 ClipboardReader* ClipboardReader::Create(SystemClipboard* system_clipboard,
                                          const String& mime_type,
-                                         ClipboardPromise* promise,
-                                         bool is_custom_format_type) {
-  DCHECK(ClipboardWriter::IsValidType(mime_type, is_custom_format_type));
-  // If this is a custom format then read the unsanitized version.
-  if (is_custom_format_type &&
-      RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled()) {
+                                         ClipboardPromise* promise) {
+  DCHECK(ClipboardWriter::IsValidType(mime_type));
+  // If this is a web custom format then read the unsanitized version.
+  if (RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() &&
+      !Clipboard::ParseWebCustomFormat(mime_type).IsNull()) {
+    // We read the custom MIME type that has the "web " prefix.
+    // These MIME types are found in the web custom format map written by
+    // native applications.
     return MakeGarbageCollected<ClipboardCustomFormatReader>(
         system_clipboard, promise, mime_type);
   }
diff --git a/blink/renderer/modules/clipboard/clipboard_reader.h b/blink/renderer/modules/clipboard/clipboard_reader.h
index abbf2dce60bb..1e123431acab 100644
--- a/blink/renderer/modules/clipboard/clipboard_reader.h
+++ b/blink/renderer/modules/clipboard/clipboard_reader.h
@@ -43,8 +43,7 @@ class ClipboardReader : public GarbageCollected<ClipboardReader> {
   // ClipboardWriter::IsValidType() must return true for `mime_type`.
   static ClipboardReader* Create(SystemClipboard* system_clipboard,
                                  const String& mime_type,
-                                 ClipboardPromise* promise,
-                                 bool is_custom_format_type);
+                                 ClipboardPromise* promise);
   virtual ~ClipboardReader();
 
   // Reads from the system clipboard and encodes on a background thread.
diff --git a/blink/renderer/modules/clipboard/clipboard_writer.cc b/blink/renderer/modules/clipboard/clipboard_writer.cc
index 9ef088c9ff90..aa8421a6c4a4 100644
--- a/blink/renderer/modules/clipboard/clipboard_writer.cc
+++ b/blink/renderer/modules/clipboard/clipboard_writer.cc
@@ -15,6 +15,7 @@
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/frame/web_feature.h"
 #include "third_party/blink/renderer/core/imagebitmap/image_bitmap.h"
+#include "third_party/blink/renderer/modules/clipboard/clipboard.h"
 #include "third_party/blink/renderer/platform/image-decoders/image_decoder.h"
 #include "third_party/blink/renderer/platform/runtime_enabled_features.h"
 #include "third_party/blink/renderer/platform/scheduler/public/post_cross_thread_task.h"
@@ -23,6 +24,7 @@
 #include "third_party/blink/renderer/platform/wtf/cross_thread_copier_skia.h"
 #include "third_party/blink/renderer/platform/wtf/cross_thread_functional.h"
 #include "third_party/blink/renderer/platform/wtf/wtf.h"
+#include "ui/base/clipboard/clipboard_constants.h"
 
 namespace blink {
 
@@ -258,13 +260,17 @@ class ClipboardCustomFormatWriter final : public ClipboardWriter {
 // static
 ClipboardWriter* ClipboardWriter::Create(SystemClipboard* system_clipboard,
                                          const String& mime_type,
-                                         ClipboardPromise* promise,
-                                         bool is_custom_format_type) {
-  DCHECK(ClipboardWriter::IsValidType(mime_type, is_custom_format_type));
-  if (is_custom_format_type &&
-      RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled()) {
+                                         ClipboardPromise* promise) {
+  DCHECK(ClipboardWriter::IsValidType(mime_type));
+  if (RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() &&
+      !Clipboard::ParseWebCustomFormat(mime_type).IsEmpty()) {
+    // We write the custom MIME type without the "web " prefix into the web
+    // custom format map so native applications don't have to add any string
+    // parsing logic to read format from clipboard.
     return MakeGarbageCollected<ClipboardCustomFormatWriter>(
-        system_clipboard, promise, mime_type);
+        system_clipboard, promise,
+        mime_type.Substring(
+            static_cast<unsigned>(std::strlen(ui::kWebClipboardFormatPrefix))));
   }
   if (mime_type == kMimeTypeImagePng) {
     return MakeGarbageCollected<ClipboardImageWriter>(system_clipboard,
@@ -299,11 +305,10 @@ ClipboardWriter::~ClipboardWriter() {
 }
 
 // static
-bool ClipboardWriter::IsValidType(const String& type,
-                                  bool is_custom_format_type) {
-  if (is_custom_format_type) {
-    return RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() &&
-           type.length() < mojom::blink::ClipboardHost::kMaxFormatSize;
+bool ClipboardWriter::IsValidType(const String& type) {
+  if (RuntimeEnabledFeatures::ClipboardCustomFormatsEnabled() &&
+      !Clipboard::ParseWebCustomFormat(type).IsEmpty()) {
+    return type.length() < mojom::blink::ClipboardHost::kMaxFormatSize;
   }
   if (type == kMimeTypeImageSvg)
     return RuntimeEnabledFeatures::ClipboardSvgEnabled();
diff --git a/blink/renderer/modules/clipboard/clipboard_writer.h b/blink/renderer/modules/clipboard/clipboard_writer.h
index 278f10426d03..97776968405f 100644
--- a/blink/renderer/modules/clipboard/clipboard_writer.h
+++ b/blink/renderer/modules/clipboard/clipboard_writer.h
@@ -57,8 +57,7 @@ class ClipboardWriter : public GarbageCollected<ClipboardWriter>,
   // IsValidType() must return true on types passed into `mime_type`.
   static ClipboardWriter* Create(SystemClipboard* system_clipboard,
                                  const String& mime_type,
-                                 ClipboardPromise* promise,
-                                 bool is_custom_format_type);
+                                 ClipboardPromise* promise);
 
   ~ClipboardWriter() override;
 
@@ -70,7 +69,7 @@ class ClipboardWriter : public GarbageCollected<ClipboardWriter>,
   // IsValidType() is used for both ClipboardWriter and ClipboardReader, as read
   // and write currently support the same types. If this changes in the future,
   // please create separate IsValidType functions.
-  static bool IsValidType(const String& mime_type, bool is_custom_format_type);
+  static bool IsValidType(const String& mime_type);
   // Begins the sequence of writing the Blob to the system clipbaord.
   void WriteToSystem(Blob* blob);
 
diff --git a/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py b/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py
index a835d91c7941..e6f5913fd9f2 100755
--- a/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py
+++ b/blink/tools/blinkpy/presubmit/audit_non_blink_usage.py
@@ -1734,6 +1734,12 @@
             'base::Value',
         ],
     },
+    {
+        'paths': ['third_party/blink/renderer/modules/clipboard/'],
+        'allowed': [
+            'net::ParseMimeTypeWithoutParameter',
+        ],
+    },
 ]
 
 
diff --git a/blink/web_tests/clipboard/async-clipboard/async-custom-format-write-read.tentative.https.html b/blink/web_tests/clipboard/async-clipboard/async-custom-format-write-read.tentative.https.html
index 779722ea6bd9..507de149bcd4 100644
--- a/blink/web_tests/clipboard/async-clipboard/async-custom-format-write-read.tentative.https.html
+++ b/blink/web_tests/clipboard/async-clipboard/async-custom-format-write-read.tentative.https.html
@@ -13,10 +13,9 @@
 'use strict';
 
 async function customFormatWriteBeforeTest() {
-  const format = 'text/customformat';
+  const format = 'web text/customformat';
   const blob = new Blob(['CustomFormatClipboardDisabled'], {type: format});
-  const clipboardItem = new ClipboardItem(
-    {[format]: blob}, {unsanitized: [format]});
+  const clipboardItem = new ClipboardItem({[format]: blob});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItem]);
 }
@@ -32,20 +31,18 @@
   // message when the ClipboardCustomFormats flag isn't enabled.
   await customFormatWriteBeforeTest();
   const dataToWrite = 'Test text.';
-  const format = 'text/plain';
+  const format = 'web text/plain';
 
   const blobInput = new Blob([dataToWrite], {type: format});
   // Blob types are automatically converted to lower-case.
   assert_equals(blobInput.type, format.toLowerCase());
-  const clipboardItemInput = new ClipboardItem(
-      {[format]: blobInput}, {unsanitized: [format]});
+  const clipboardItemInput = new ClipboardItem({[format]: blobInput});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
 
   // Items should be readable on a system clipboard after custom format write.
   await waitForUserActivation();
-  const clipboardItems = await navigator.clipboard.read(
-    {unsanitized: [format]});
+  const clipboardItems = await navigator.clipboard.read();
   assert_equals(clipboardItems.length, 1);
   const clipboardItem = clipboardItems[0];
   assert_true(clipboardItem instanceof ClipboardItem);
@@ -55,9 +52,9 @@
   const data = await (new Response(blobOutput)).text();
   assert_equals(data, dataToWrite);
 
-  // These examples use native text formats, so these formats should be
+  // These examples use web custom text format, so this format shouldn't be
   // accessible as text.
   const textOutput = await navigator.clipboard.readText();
-  assert_equals(textOutput, dataToWrite);
-}, 'Verify write and read clipboard given custom formats as input');
+  assert_not_equals(textOutput, dataToWrite);
+}, 'Verify write and read clipboard given web custom format as input');
 </script>
diff --git a/blink/web_tests/clipboard/async-clipboard/async-custom-formats-write-read.tentative.https.html b/blink/web_tests/clipboard/async-clipboard/async-custom-formats-write-read.tentative.https.html
index b5609563762c..0f5505e152dc 100644
--- a/blink/web_tests/clipboard/async-clipboard/async-custom-formats-write-read.tentative.https.html
+++ b/blink/web_tests/clipboard/async-clipboard/async-custom-formats-write-read.tentative.https.html
@@ -16,24 +16,18 @@
   await PermissionsHelper.setPermission('clipboard-read-write', 'granted');
   await PermissionsHelper.setPermission('clipboard-sanitized-write',
                                         'granted');
-  const format1 = 'application/x-custom-format-clipboard-test-format-1';
-  const format2 = 'application/x-custom-format-clipboard-test-format-2';
+  const format1 = 'web application/x-custom-format-clipboard-test-format-1';
+  const format2 = 'web application/x-custom-format-clipboard-test-format-2';
   const blobInput1 = new Blob(['input data 1'], {type: format1});
   const blobInput2 = new Blob(['input data 2'], {type: format2});
   const clipboardItemInput = new ClipboardItem(
-      {[format1]: blobInput1, [format2]: blobInput2},
-      {unsanitized: [format1, format2]});
+      {[format1]: blobInput1, [format2]: blobInput2});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
 
-  // Items may not be readable on the sanitized clipboard after custom format write.
-  await promise_rejects_dom(t, 'DataError',
-      navigator.clipboard.read());
-
   // Items should be readable on a custom format clipboard after custom format write.
   await waitForUserActivation();
-  const clipboardItems = await navigator.clipboard.read(
-    {unsanitized: [format1, format2]});
+  const clipboardItems = await navigator.clipboard.read();
   assert_equals(clipboardItems.length, 1);
   const clipboardItem = clipboardItems[0];
   assert_true(clipboardItem instanceof ClipboardItem);
@@ -42,12 +36,12 @@
 
   const blobOutput1 = await clipboardItem.getType(format1);
   assert_equals(blobOutput1.type, format1);
-  const data1 = await (new Response(blobOutput1)).text();
+  const data1 = await blobOutput1.text();
   assert_equals(data1, 'input data 1');
 
   const blobOutput2 = await clipboardItem.getType(format2);
   assert_equals(blobOutput2.type, format2);
-  const data2 = await (new Response(blobOutput2)).text();
+  const data2 = await blobOutput2.text();
   assert_equals(data2, 'input data 2');
 }, 'Verify write and read clipboard given 2 platform-neutral custom format inputs');
 </script>
diff --git a/blink/web_tests/clipboard/async-clipboard/async-navigator-clipboard-basics.https.html b/blink/web_tests/clipboard/async-clipboard/async-navigator-clipboard-basics.https.html
index 02b503fd70c0..ef2bc8cbcc83 100644
--- a/blink/web_tests/clipboard/async-clipboard/async-navigator-clipboard-basics.https.html
+++ b/blink/web_tests/clipboard/async-clipboard/async-navigator-clipboard-basics.https.html
@@ -2,9 +2,13 @@
 <meta charset="utf-8">
 <title>Async Clipboard input type validation tests</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="../../resources/testharness.js"></script>
 <script src="../../resources/testharnessreport.js"></script>
 <script src="../../http/tests/resources/permissions-helper.js"></script>
+<script src="../../resources/testdriver.js"></script>
+<script src="../../resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 <script>
 // Permissions are required in order to invoke navigator.clipboard functions in
 // an automated test.
@@ -24,6 +28,7 @@
   const promise_blob = Promise.resolve(new Blob(['hello'], {type: 'text/plain'}));
   const item = new ClipboardItem({'text/plain': promise_blob});
 
+  await waitForUserActivation();
   await navigator.clipboard.write([item]);
 }, 'navigator.clipboard.write(Promise<Blob>) succeeds');
 
@@ -33,6 +38,7 @@
   const promise_html_blob = Promise.resolve(new Blob(["<p style='color: red; font-style: oblique;'>Test</p>"], {type: 'text/html'}));
   const item = new ClipboardItem({'text/plain': promise_text_blob, 'text/html': promise_html_blob});
 
+  await waitForUserActivation();
   await navigator.clipboard.write([item]);
 }, 'navigator.clipboard.write(Promise<Blob>s) succeeds');
 
@@ -40,6 +46,7 @@
   await getPermissions();
   const text_plain = "This text was copied using `Clipboard.prototype.write`.";
   const html_text = "<p style='color: red; font-style: oblique;'>Test</p>";
+  await waitForUserActivation();
   await promise_rejects_dom(t, "NotAllowedError", navigator.clipboard.write([
    new ClipboardItem({
             "text/plain":  text_plain,
@@ -53,6 +60,7 @@
   const blob = new Blob(['hello'], {type: 'text/plain'});
   const item = new ClipboardItem({'text/plain': blob});
 
+  await waitForUserActivation();
   await navigator.clipboard.write([item]);
 }, 'navigator.clipboard.write([text/plain ClipboardItem]) succeeds');
 
@@ -64,22 +72,26 @@
   const item1 = new ClipboardItem({'text/plain': blob1});
   const item2 = new ClipboardItem({'text/plain': blob2});
 
+  await waitForUserActivation();
   await promise_rejects_dom(t, "NotAllowedError",
       navigator.clipboard.write([item1, item2]));
 }, 'navigator.clipboard.write([>1 ClipboardItems]) fails (not implemented)');
 
 promise_test(async t => {
   await getPermissions();
+  await waitForUserActivation();
   await promise_rejects_js(t, TypeError, navigator.clipboard.write());
 }, 'navigator.clipboard.write() fails (expect [ClipboardItem])');
 
 promise_test(async t => {
   await getPermissions();
+  await waitForUserActivation();
   await promise_rejects_js(t, TypeError, navigator.clipboard.write(null));
 }, 'navigator.clipboard.write(null) fails (expect [ClipboardItem])');
 
 promise_test(async t => {
   await getPermissions();
+  await waitForUserActivation();
   await promise_rejects_js(t, TypeError,
                            navigator.clipboard.write('Bad string'));
 }, 'navigator.clipboard.write(DOMString) fails (expect [ClipboardItem])');
@@ -87,22 +99,26 @@
 promise_test(async t => {
   await getPermissions();
   const blob = new Blob(['hello'], {type: 'text/plain'});
+  await waitForUserActivation();
   await promise_rejects_js(t, TypeError, navigator.clipboard.write(blob));
 }, 'navigator.clipboard.write(Blob) fails (expect [ClipboardItem])');
 
 promise_test(async () => {
   await getPermissions();
+  await waitForUserActivation();
   await navigator.clipboard.writeText('New clipboard text');
 }, 'navigator.clipboard.writeText(DOMString) succeeds');
 
 promise_test(async t => {
   await getPermissions();
+  await waitForUserActivation();
   await promise_rejects_js(t, TypeError,
                            navigator.clipboard.writeText());
 }, 'navigator.clipboard.writeText() fails (expect DOMString)');
 
 promise_test(async () => {
   await getPermissions();
+  await waitForUserActivation();
   const result = await navigator.clipboard.read();
   assert_true(result instanceof Object);
   assert_true(result[0] instanceof ClipboardItem);
@@ -110,6 +126,7 @@
 
 promise_test(async () => {
   await getPermissions();
+  await waitForUserActivation();
   const result = await navigator.clipboard.readText();
   assert_equals(typeof result, 'string');
 }, 'navigator.clipboard.readText() succeeds');
diff --git a/blink/web_tests/clipboard/async-clipboard/clipboard-garbage-collection-race-condition.html b/blink/web_tests/clipboard/async-clipboard/clipboard-garbage-collection-race-condition.html
index 6b813dbaa01f..1db5ca1a3d4e 100644
--- a/blink/web_tests/clipboard/async-clipboard/clipboard-garbage-collection-race-condition.html
+++ b/blink/web_tests/clipboard/async-clipboard/clipboard-garbage-collection-race-condition.html
@@ -3,10 +3,12 @@
 <title>
   Async Clipboard write garbage collection race condition test
 </title>
+<body>Body needed for test_driver.click()</body>
 <script src="../../resources/testharness.js"></script>
 <script src="../../resources/testharnessreport.js"></script>
 <script src="../../resources/testdriver.js"></script>
 <script src="../../resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 
 <script>
 promise_test(async t => {
@@ -16,6 +18,7 @@
   const clipboardItemInput = new ClipboardItem(
         {'text/plain' : blobText});
 
+  await waitForUserActivation();
   const promise = navigator.clipboard.write([clipboardItemInput]);
   for (let i = 0; i < 10; ++i) {
     // TODO(https://github.com/web-platform-tests/wpt/issues/7899): Support
diff --git a/blink/web_tests/clipboard/async-clipboard/clipboard-read-unsupported-types-removal.html b/blink/web_tests/clipboard/async-clipboard/clipboard-read-unsupported-types-removal.html
index eb2f99529d99..a28a0d358ff3 100644
--- a/blink/web_tests/clipboard/async-clipboard/clipboard-read-unsupported-types-removal.html
+++ b/blink/web_tests/clipboard/async-clipboard/clipboard-read-unsupported-types-removal.html
@@ -1,15 +1,18 @@
 <!doctype html>
 <meta charset="utf-8">
 <title>Async Clipboard read unsupported types removal test.</title>
+<body>Body needed for test_driver.click()</body>
 <script src="../../resources/testharness.js"></script>
 <script src="../../resources/testharnessreport.js"></script>
 <script src="../../resources/testdriver.js"></script>
 <script src="../../resources/testdriver-vendor.js"></script>
-<body>
+<script src="resources/user-activation.js"></script>
 <script>
 'use strict';
 
 promise_test(async t => {
+  await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
+  await waitForUserActivation();
   // Write supported and unsupported types to clipboard.
   document.addEventListener('copy', event => {
     event.clipboardData.setData('text/plain', 'Supported text.');
@@ -19,7 +22,6 @@
   document.execCommand('copy');
 
   // Read clipboard contents.
-  await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
   const clipboardItems = await navigator.clipboard.read();
 
   // The unsupported unsupported-type type should be removed, leaving only
@@ -30,4 +32,3 @@
   assert_false(clipboardItem.types.includes('unsupported-type'));
 }, 'Verify that clipboard read removes unsupported types.');
 </script>
-</body>
\ No newline at end of file
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-custom-formats-write-read.tentative.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-custom-formats-write-read.tentative.https.html
index b6c368f75bc2..77991ec98aa0 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-custom-formats-write-read.tentative.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-custom-formats-write-read.tentative.https.html
@@ -14,26 +14,19 @@
 promise_test(async t => {
   await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
-  const format1 = 'application/x-custom-format-clipboard-test-format-1';
-  const format2 = 'application/x-custom-format-clipboard-test-format-2';
+  const format1 = 'web application/x-custom-format-clipboard-test-format-1';
+  const format2 = 'web application/x-custom-format-clipboard-test-format-2';
   const blobInput1 = new Blob(['input data 1'], {type: format1});
   const blobInput2 = new Blob(['input data 2'], {type: format2});
   const clipboardItemInput = new ClipboardItem(
-      {[format1]: blobInput1, [format2]: blobInput2},
-      {unsanitized: [format1, format2]});
+      {[format1]: blobInput1, [format2]: blobInput2});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
 
-  // Items may not be readable on the sanitized clipboard after custom format
-  // write.
-  await promise_rejects_dom(t, 'DataError',
-      navigator.clipboard.read());
-
   // Items should be readable on a custom format clipboard after custom format
   // write.
   await waitForUserActivation();
-  const clipboardItems = await navigator.clipboard.read(
-    {unsanitized: [format1, format2]});
+  const clipboardItems = await navigator.clipboard.read();
   assert_equals(clipboardItems.length, 1);
   const clipboardItem = clipboardItems[0];
   assert_true(clipboardItem instanceof ClipboardItem);
@@ -58,15 +51,44 @@
   const customFormatArray = [];
   const customFormatMap = {};
   for (let i = 0; i <= 100; i++) {
-    customFormatArray.push("CustomFormat" + i);
+    customFormatArray.push("web text/CustomFormat" + i);
     const blobInput = new Blob(['input data'], {type: customFormatArray[i]});
     customFormatMap[customFormatArray[i]] = blobInput;
   }
-  const clipboardItemInput = new ClipboardItem(customFormatMap,
-      {unsanitized: customFormatArray});
+  const clipboardItemInput = new ClipboardItem(customFormatMap);
   await waitForUserActivation();
   await promise_rejects_dom(t, 'NotAllowedError',
       navigator.clipboard.write([clipboardItemInput]));
 }, 'navigator.clipboard.write() fails for more than 100 custom formats');
 
+promise_test(async t => {
+  await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
+  await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
+
+  const format1 = 'application/x-custom-format-clipboard-test-format-1';
+  const format2 = 'application/x-custom-format-clipboard-test-format-2';
+  const blobInput1 = new Blob(['input data 1'], {type: format1});
+  const blobInput2 = new Blob(['input data 2'], {type: format2});
+  const clipboardItemInput = new ClipboardItem(
+      {[format1]: blobInput1, [format2]: blobInput2});
+  await waitForUserActivation();
+  await promise_rejects_dom(t, 'NotAllowedError',
+      navigator.clipboard.write([clipboardItemInput]));
+}, 'navigator.clipboard.write() fails for custom formats without web prefix');
+
+promise_test(async t => {
+  await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
+  await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
+
+  const format1 = 'web ';
+  const format2 = 'web a';
+  const blobInput1 = new Blob(['input data 1'], {type: format1});
+  const blobInput2 = new Blob(['input data 2'], {type: format2});
+  const clipboardItemInput = new ClipboardItem(
+      {[format1]: blobInput1, [format2]: blobInput2});
+  await waitForUserActivation();
+  await promise_rejects_dom(t, 'NotAllowedError',
+      navigator.clipboard.write([clipboardItemInput]));
+}, 'navigator.clipboard.write() fails for custom formats with web prefix, but invalid MIME types');
+
 </script>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-html-script-removal.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-html-script-removal.https.html
index 90dc44c9db20..44c11add8551 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-html-script-removal.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-html-script-removal.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write ([text/html ClipboardItem]) -> readHtml (and remove scripts) tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 <script>
 'use strict';
 // This function removes extra spaces between tags in html. For example, the
@@ -36,8 +38,10 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
   const blobInput = new Blob([html_with_script], {type: 'text/html'});
   const clipboardItem = new ClipboardItem({'text/html': blobInput});
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItem]);
-  const clipboardItems = await navigator.clipboard.read({type: 'text/html'});
+  await waitForUserActivation();
+  const clipboardItems = await navigator.clipboard.read();
 
   const html = clipboardItems[0];
   assert_equals(html.types.length, 1);
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-resource-load.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-resource-load.https.html
index 5f74be1a8228..d1e3019e7f93 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-resource-load.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-resource-load.https.html
@@ -7,7 +7,9 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 
+<body>Body needed for test_driver.click()
 <p><button id="button">Put payload in the clipboard</button></p>
 <div id="output"></div>
 
@@ -27,6 +29,7 @@
   await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
   await test_driver.click(button);
 
+  await waitForUserActivation();
   const items = await navigator.clipboard.read();
   const htmlBlob = await items[0].getType("text/html");
   const html = await htmlBlob.text();
@@ -38,3 +41,4 @@
   assert_false(loadObserved, 'Should not observe resource loading');
 });
 </script>
+</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-sanitize.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-sanitize.https.html
index 9e0ab2ee740f..cc1836753478 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-sanitize.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-navigator-clipboard-read-sanitize.https.html
@@ -7,7 +7,9 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 
+<body>Body needed for test_driver.click()
 <p><button id="button">Put payload in the clipboard</button></p>
 <div id="output"></div>
 
@@ -29,6 +31,7 @@
   await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
   await test_driver.click(button);
 
+  await waitForUserActivation();
   const items = await navigator.clipboard.read();
   const htmlBlob = await items[0].getType("text/html");
   const html = await htmlBlob.text();
@@ -42,3 +45,4 @@
   assert_false(testFailed);
 });
 </script>
+</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-promise-write-blobs-read-blobs.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-promise-write-blobs-read-blobs.https.html
index e4b93c7c5ffb..12184c92e077 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-promise-write-blobs-read-blobs.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-promise-write-blobs-read-blobs.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write blobs -> read blobs with promise tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 
 <script>
 async function loadBlob(fileName) {
@@ -26,8 +28,9 @@
 
   const clipboardItemInput = new ClipboardItem(
         {'text/plain' : blobText, 'image/png' : promise1});
-
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
+  await waitForUserActivation();
   const clipboardItems = await navigator.clipboard.read();
 
   assert_equals(clipboardItems.length, 1);
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-svg-script-removal.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-svg-script-removal.https.html
index cd1a551d9d12..292d100b2fc7 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-svg-script-removal.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-svg-script-removal.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write ([image/svg+xml ClipboardItem]) -> readSvg (and remove scripts) tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 <script>
 'use strict';
 // This function removes extra spaces between tags in svg. For example, the
@@ -36,7 +38,9 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
   const blobInput = new Blob([svg_with_script], {type: 'image/svg+xml'});
   const clipboardItem = new ClipboardItem({'image/svg+xml': blobInput});
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItem]);
+  await waitForUserActivation();
   const clipboardItems =
       await navigator.clipboard.read({type: 'image/svg+xml'});
 
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-html-formats-write-read.tentative.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-html-formats-write-read.tentative.https.html
index 887ba8a484fd..ffe6a31c2a7a 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-html-formats-write-read.tentative.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-html-formats-write-read.tentative.https.html
@@ -32,20 +32,18 @@
 
   // Create and write unsanitized version of standard HTML and custom formats.
   const format1 = 'text/html';
-  const format2 = 'application/x-custom-format-clipboard-test-format-2';
+  const format2 = 'web text/html';
   const textInput = '<style>p {color:blue}</style><p>Hello World</p>';
-  const blobInput1 = new Blob([textInput], {type: 'text/html'});
-  const blobInput2 = new Blob(['input data 2'], {type: format2});
+  const blobInput1 = new Blob([textInput], {type: format1});
+  const blobInput2 = new Blob([textInput], {type: format2});
   const clipboardItemInput = new ClipboardItem(
-      {[format1]: blobInput1, [format2]: blobInput2},
-      {unsanitized: [format1, format2]});
+      {[format1]: blobInput1, [format2]: blobInput2});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
 
   // Read unsanitized version of HTML format.
   await waitForUserActivation();
-  const clipboardItems = await navigator.clipboard.read(
-    {unsanitized: [format1, format2]});
+  const clipboardItems = await navigator.clipboard.read();
 
   assert_equals(clipboardItems.length, 1);
   const clipboardItem = clipboardItems[0];
@@ -55,12 +53,20 @@
   assert_equals(blobOutput1.type, format1);
   const data1 = await (new Response(blobOutput1)).text();
   const outputHtml = reformatHtml(data1);
-  const inputHtml = reformatHtml(textInput);
+  const expectedHtml = '<p style="color: blue; font-size: medium; font-style: normal; ' +
+                       'font-variant-ligatures: normal; font-variant-caps: normal; ' +
+                       'font-weight: 400; letter-spacing: normal; orphans: 2; ' +
+                       'text-align: start; text-indent: 0px; text-transform: none; '+
+                       'white-space: normal; widows: 2; word-spacing: 0px; ' +
+                       '-webkit-text-stroke-width: 0px; text-decoration-thickness: initial; ' +
+                       'text-decoration-style: initial; text-decoration-color: initial;">' +
+                       'Hello World</p>';
+  const inputHtml = reformatHtml(expectedHtml);
   assert_equals(outputHtml, inputHtml);
 
   const blobOutput2 = await clipboardItem.getType(format2);
   assert_equals(blobOutput2.type, format2);
   const data2 = await (new Response(blobOutput2)).text();
-  assert_equals(data2, 'input data 2');
+  assert_equals(data2, textInput);
 }, 'Verify write and read unsanitized content to the clipboard given text/html format as input');
 </script>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-plaintext-formats-write-read.tentative.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-plaintext-formats-write-read.tentative.https.html
index f44ed22618e2..1c5638ca0a5f 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-plaintext-formats-write-read.tentative.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-unsanitized-plaintext-formats-write-read.tentative.https.html
@@ -18,32 +18,35 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
 
   const dataToWrite = 'Test text.';
-  const format = 'text/plain';
+  const format1 = 'web text/plain';
+  const format2 = 'text/plain';
 
-  const blobInput = new Blob([dataToWrite], {type: format});
+  const blobInput1 = new Blob([dataToWrite], {type: format1});
+  const blobInput2 = new Blob([dataToWrite], {type: format2});
   // Blob types are automatically converted to lower-case.
-  assert_equals(blobInput.type, format.toLowerCase());
+  assert_equals(blobInput1.type, format1.toLowerCase());
+  assert_equals(blobInput2.type, format2.toLowerCase());
   const clipboardItemInput = new ClipboardItem(
-      {[format]: blobInput}, {unsanitized: [format]});
+      {[format1]: blobInput1, [format2]: blobInput2});
   await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
 
   // Items should be readable on a system clipboard after custom format write.
   await waitForUserActivation();
-  const clipboardItems = await navigator.clipboard.read(
-    {unsanitized: [format]});
+  const clipboardItems = await navigator.clipboard.read();
   assert_equals(clipboardItems.length, 1);
   const clipboardItem = clipboardItems[0];
   assert_true(clipboardItem instanceof ClipboardItem);
 
-  const blobOutput = await clipboardItem.getType(format);
-  assert_equals(blobOutput.type, format);
-  const data = await (new Response(blobOutput)).text();
-  assert_equals(data, dataToWrite);
+  const blobOutput1 = await clipboardItem.getType(format1);
+  assert_equals(blobOutput1.type, format1);
+  const data1 = await (new Response(blobOutput1)).text();
+  assert_equals(data1, dataToWrite);
 
   // These examples use native text formats, so these formats should be
   // accessible as text.
+  await waitForUserActivation();
   const textOutput = await navigator.clipboard.readText();
   assert_equals(textOutput, dataToWrite);
-}, 'Verify write and read unsanitized content to the clipboard given standard format as input');
+}, 'Verify write and read unsanitized content to the clipboard given standard and custom formats as input');
 </script>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-write-blobs-read-blobs.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-write-blobs-read-blobs.https.html
index 50d23a9c3625..8bec558b2b2d 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-write-blobs-read-blobs.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-write-blobs-read-blobs.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write blobs -> read blobs tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 
 <script>
 async function loadBlob(fileName) {
@@ -28,7 +30,9 @@
   const clipboardItemInput = new ClipboardItem(
         {'text/plain' : blobText, 'image/png' : blobImage});
 
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
+  await waitForUserActivation();
   const clipboardItems = await navigator.clipboard.read();
 
   assert_equals(clipboardItems.length, 1);
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-write-html-read-html.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-write-html-read-html.https.html
index 7c271b9bd78d..ec1817c027bb 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-write-html-read-html.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-write-html-read-html.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write ([text/html ClipboardItem]) -> readHtml tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 <script>
 'use strict';
 // This function removes extra spaces between tags in html. For example, the
@@ -28,7 +30,9 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
   const blobInput = new Blob([textInput], {type: 'text/html'});
   const clipboardItem = new ClipboardItem({'text/html': blobInput});
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItem]);
+  await waitForUserActivation();
   const clipboardItems = await navigator.clipboard.read({type: 'text/html'});
 
   const html = clipboardItems[0];
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-write-image-read-image.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-write-image-read-image.https.html
index 281358dfc5f8..e10b69d824c2 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-write-image-read-image.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-write-image-read-image.https.html
@@ -9,6 +9,8 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
+<body>Body needed for test_driver.click()
 <p>
   <p>The bottom image should display the same image as the top image.</p>
   <p>Original Image:</p>
@@ -47,7 +49,9 @@
 
   assert_equals(blobInput.type, 'image/png');
   const clipboardItemInput = new ClipboardItem({'image/png' : blobInput});
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItemInput]);
+  await waitForUserActivation();
   const clipboardItems = await navigator.clipboard.read();
 
   assert_equals(clipboardItems.length, 1);
@@ -73,7 +77,9 @@
   const invalidPngBlob = new Blob(['this text is not a valid png image'],
       {type: 'image/png'});
   const clipboardItemInput = new ClipboardItem({'image/png' : invalidPngBlob});
+  await waitForUserActivation();
   await promise_rejects_dom(t, 'DataError',
       navigator.clipboard.write([clipboardItemInput]));
 }, 'Verify write error on malformed data [image/png ClipboardItem]');
 </script>
+</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/async-write-svg-read-svg.https.html b/blink/web_tests/external/wpt/clipboard-apis/async-write-svg-read-svg.https.html
index 19c91597c111..42f6c547b297 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/async-write-svg-read-svg.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/async-write-svg-read-svg.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write ([image/svg+xml ClipboardItem]) -> read and write svg tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="resources/user-activation.js"></script>
 <script>
 'use strict';
 // This function removes extra spaces between tags in svg. For example, the
@@ -28,7 +30,9 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
   const blobInput = new Blob([textInput], {type: 'image/svg+xml'});
   const clipboardItem = new ClipboardItem({'image/svg+xml': blobInput});
+  await waitForUserActivation();
   await navigator.clipboard.write([clipboardItem]);
+  await waitForUserActivation();
   const clipboardItems =
       await navigator.clipboard.read({type: 'image/svg+xml'});
 
diff --git a/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/write-read-on-detached-iframe.https.html b/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/write-read-on-detached-iframe.https.html
index c0f11772929e..b21e6b20bc0d 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/write-read-on-detached-iframe.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/write-read-on-detached-iframe.https.html
@@ -6,6 +6,7 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <iframe id="iframe"></iframe>
 <script>
 'use strict';
@@ -21,6 +22,7 @@
   const iframeClipboard = iframe.contentWindow.navigator.clipboard;
   const blobInput = new Blob(['test string'], {type: 'text/plain'});
   const clipboardItemInput = new ClipboardItem({'text/plain': blobInput});
+  await waitForUserActivation();
   // Clipboard API must only be available in focused documents.
   // reference: https://www.w3.org/TR/clipboard-apis/#privacy-async
   iframe.focus();
diff --git a/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/writeText-readText-on-detached-iframe.https.html b/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/writeText-readText-on-detached-iframe.https.html
index 9cd8900aab0f..24fa586fc770 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/writeText-readText-on-detached-iframe.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/detached-iframe/writeText-readText-on-detached-iframe.https.html
@@ -6,6 +6,7 @@
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <iframe id="iframe"></iframe>
 <script>
 'use strict';
@@ -15,6 +16,7 @@
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
 
   const iframe = document.getElementById('iframe');
+  await waitForUserActivation();
   // Clipboard API must only be available in focused documents.
   // reference: https://www.w3.org/TR/clipboard-apis/#privacy-async
   iframe.focus();
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
index 3b1cfd52ad7c..367d033d0f6a 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -17,7 +18,8 @@
 // In Chrome and Firefox, Cross-origin focus requires user gesture. In Chrome
 // only, cross-origin focus is asynchronous. Implement WPT support for
 // cross-origin focus.
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -27,4 +29,3 @@
   );
 }, 'Feature policy "clipboard-read" can be enabled in cross-origin iframe using allow="clipboard-read" attribute');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-tentative.https.sub.html
index 15d268426163..e812854b4c75 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-attribute-tentative.https.sub.html
@@ -1,17 +1,19 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 const same_origin_src =
   '/feature-policy/resources/feature-policy-clipboard-read.html';
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -21,4 +23,3 @@
   );
 }, 'Feature policy "clipboard-read" can be enabled in same-origin iframe using allow="clipboard-read" attribute');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-cross-origin-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
index 1b6f4929a19d..c371ea3b41cb 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -17,7 +18,8 @@
 // In Chrome and Firefox, Cross-origin focus requires user gesture. In Chrome
 // only, cross-origin focus is asynchronous. Implement WPT support for
 // cross-origin focus.
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -26,4 +28,3 @@
   );
 }, 'Feature-Policy header clipboard-read "*" allows cross-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy.tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy.tentative.https.sub.html
index f8c5bcb129f9..552183cc67d4 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy.tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-by-feature-policy.tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -15,10 +16,12 @@
 
 promise_test(async t => {
   await test_driver.set_permission({ name: 'clipboard-read' }, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.readText('test text');
 }, 'Feature-Policy header clipboard-read "*" allows the top-level document.');
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -27,4 +30,3 @@
   );
 }, 'Feature-Policy header clipboard-read "*" allows same-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
index 47aa6511ec59..17dc3628a772 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-read/clipboard-read-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -15,10 +16,12 @@
 
 promise_test(async t => {
   await test_driver.set_permission({ name: 'clipboard-read' }, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.readText('test text');
 }, 'Feature-Policy header clipboard-read "self" allows the top-level document.');
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -27,7 +30,11 @@
   );
 }, 'Feature-Policy header clipboard-read "self" allows same-origin iframes.');
 
-async_test(t => {
+// TODO(https://github.com/whatwg/html/issues/5493, https://crbug.com/1074482):
+// In Chrome and Firefox, Cross-origin focus requires user gesture. In Chrome
+// only, cross-origin focus is asynchronous. Implement WPT support for
+// cross-origin focus.
+promise_test(async t => {
   test_feature_availability(
     'navigator.clipboard.readText()',
     t,
@@ -36,4 +43,3 @@
   );
 }, 'Feature-Policy header clipboard-read "self" disallows cross-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
index c931bbbb89f3..e669c8fec491 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-cross-origin-tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -17,7 +18,8 @@
 // In Chrome and Firefox, Cross-origin focus requires user gesture. In Chrome
 // only, cross-origin focus is asynchronous. Implement WPT support for
 // cross-origin focus.
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -27,4 +29,3 @@
   );
 }, 'Feature policy "clipboard-write" can be enabled in cross-origin iframe using allow="clipboard-write" attribute');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-tentative.https.sub.html
index a2858c638e6c..b57dfe3dd288 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-attribute-tentative.https.sub.html
@@ -1,17 +1,19 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 const same_origin_src =
   '/feature-policy/resources/feature-policy-clipboard-write.html';
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -21,4 +23,3 @@
   );
 }, 'Feature policy "clipboard-write" can be enabled in same-origin iframe using allow="clipboard-write" attribute');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-cross-origin-tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
index 0f3164d9b02a..6e7029cc789a 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy-cross-origin-tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -17,7 +18,8 @@
 // In Chrome and Firefox, Cross-origin focus requires user gesture. In Chrome
 // only, cross-origin focus is asynchronous. Implement WPT support for
 // cross-origin focus.
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -26,4 +28,3 @@
   );
 }, 'Feature-Policy header clipboard-write "*" allows cross-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy.tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy.tentative.https.sub.html
index 1c6fc49a0566..ca97994c617d 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy.tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-by-feature-policy.tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -15,10 +16,12 @@
 
 promise_test(async t => {
   await test_driver.set_permission({ name: 'clipboard-write' }, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.writeText('test text');
 }, 'Feature-Policy header clipboard-write "*" allows the top-level document.');
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -27,4 +30,3 @@
   );
 }, 'Feature-Policy header clipboard-write "*" allows same-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
index 51db5a427d2b..5615a68ac55a 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/feature-policy/clipboard-write/clipboard-write-enabled-on-self-origin-by-feature-policy.tentative.https.sub.html
@@ -1,10 +1,11 @@
 <!doctype html>
-<body>
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
 <script src="/feature-policy/resources/featurepolicy.js"></script>
+<script src="../../resources/user-activation.js"></script>
 <script>
 'use strict';
 
@@ -15,10 +16,12 @@
 
 promise_test(async t => {
   await test_driver.set_permission({ name: 'clipboard-write' }, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.writeText('test text');
 }, 'Feature-Policy header clipboard-write "self" allows the top-level document.');
 
-async_test(t => {
+promise_test(async t => {
+  await waitForUserActivation();
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -27,7 +30,7 @@
   );
 }, 'Feature-Policy header clipboard-write "self" allows same-origin iframes.');
 
-async_test(t => {
+promise_test(async t => {
   test_feature_availability(
     'navigator.clipboard.writeText("test text")',
     t,
@@ -36,4 +39,3 @@
   );
 }, 'Feature-Policy header clipboard-write "self" disallows cross-origin iframes.');
 </script>
-</body>
diff --git a/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-denied.https.html b/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-denied.https.html
index 935f520e7de2..010f4ba21b95 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-denied.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-denied.https.html
@@ -2,15 +2,18 @@
 <meta charset="utf-8">
 <title>navigator.clipboard.readText() fails when permission denied</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 promise_test(async t => {
   await test_driver.set_permission({name: 'clipboard-read'}, 'denied');
+  await waitForUserActivation();
   await promise_rejects_dom(t,
       'NotAllowedError', navigator.clipboard.readText());
 }, 'navigator.clipboard.readText() fails when permission denied');
diff --git a/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-granted.https.html b/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-granted.https.html
index ab76cd5e1da8..e912bd64a831 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-granted.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/permissions/readText-granted.https.html
@@ -2,15 +2,18 @@
 <meta charset="utf-8">
 <title>navigator.clipboard.readText() succeeds when permission granted</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 promise_test(async () => {
   await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.readText();
 }, 'navigator.clipboard.readText() succeeds when permission granted');
 </script>
\ No newline at end of file
diff --git a/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-denied.https.html b/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-denied.https.html
index 4d0530f0bc22..5fbcab411748 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-denied.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-denied.https.html
@@ -2,15 +2,18 @@
 <meta charset="utf-8">
 <title>navigator.clipboard.writeText() fails when permission denied</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 promise_test(async t => {
   await test_driver.set_permission({name: 'clipboard-write'}, 'denied');
+  await waitForUserActivation();
   await promise_rejects_dom(t, 'NotAllowedError',
       navigator.clipboard.writeText('xyz'));
 }, 'navigator.clipboard.writeText() fails when permission denied');
diff --git a/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-granted.https.html b/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-granted.https.html
index b03ae7ff26b5..ff347b7adda0 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-granted.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/permissions/writeText-granted.https.html
@@ -2,15 +2,18 @@
 <meta charset="utf-8">
 <title>navigator.clipboard.writeText() succeeds when permission granted</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 'use strict';
 
 promise_test(async () => {
   await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
+  await waitForUserActivation();
   await navigator.clipboard.writeText('xyz');
 }, 'navigator.clipboard.writeText() succeeds when permission granted');
 </script>
\ No newline at end of file
diff --git a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-read.https.html b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-read.https.html
index a00c5b27a4d6..c46e5d431713 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-read.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-read.https.html
@@ -5,10 +5,12 @@
         read ([text/plain ClipboardItem]) tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 async function readWriteTest(textInput) {
   promise_test(async t => {
@@ -18,7 +20,9 @@
     const blobInput = new Blob([textInput], {type: 'text/plain'});
     const clipboardItemInput = new ClipboardItem({'text/plain': blobInput});
 
+    await waitForUserActivation();
     await navigator.clipboard.write([clipboardItemInput]);
+    await waitForUserActivation();
     const clipboardItems = await navigator.clipboard.read();
     assert_equals(clipboardItems.length, 1);
     const clipboardItemOutput = clipboardItems[0];
diff --git a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-readText.https.html b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-readText.https.html
index e8156af47f4c..66969b1777b2 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-readText.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-write-readText.https.html
@@ -4,10 +4,12 @@
   Async Clipboard write ([text/plain ClipboardItem]) -> readText tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 async function readWriteTest(textInput) {
   promise_test(async t => {
@@ -17,7 +19,9 @@
     const blobInput = new Blob([textInput], {type: 'text/plain'});
     const clipboardItem = new ClipboardItem({'text/plain': blobInput});
 
+    await waitForUserActivation();
     await navigator.clipboard.write([clipboardItem]);
+    await waitForUserActivation();
     const textOutput = await navigator.clipboard.readText();
 
     assert_equals(textOutput, textInput);
diff --git a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-read.https.html b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-read.https.html
index 4a37aa1a5f73..ddf563269a42 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-read.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-read.https.html
@@ -4,17 +4,21 @@
   Async Clipboard writeText -> read ([text/plain ClipboardItem]) tests
 </title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 async function readWriteTest(textInput) {
   promise_test(async t => {
     await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
     await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
 
+    await waitForUserActivation();
     await navigator.clipboard.writeText(textInput);
+    await waitForUserActivation();
     const clipboardItems = await navigator.clipboard.read();
     assert_equals(clipboardItems.length, 1);
     const clipboardItem = clipboardItems[0];
diff --git a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-readText.https.html b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-readText.https.html
index 7e56bfef2c68..0defdf7a7095 100644
--- a/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-readText.https.html
+++ b/blink/web_tests/external/wpt/clipboard-apis/text-write-read/async-writeText-readText.https.html
@@ -2,17 +2,21 @@
 <meta charset="utf-8">
 <title>Async Clipboard writeText -> readText tests</title>
 <link rel="help" href="https://w3c.github.io/clipboard-apis/#async-clipboard-api">
+<body>Body needed for test_driver.click()</body>
 <script src="/resources/testharness.js"></script>
 <script src="/resources/testharnessreport.js"></script>
 <script src="/resources/testdriver.js"></script>
 <script src="/resources/testdriver-vendor.js"></script>
+<script src="../resources/user-activation.js"></script>
 <script>
 async function readWriteTest(textInput) {
   promise_test(async t => {
     await test_driver.set_permission({name: 'clipboard-read'}, 'granted');
     await test_driver.set_permission({name: 'clipboard-write'}, 'granted');
 
+    await waitForUserActivation();
     await navigator.clipboard.writeText(textInput);
+    await waitForUserActivation();
     const textOutput = await navigator.clipboard.readText();
 
     assert_equals(textOutput, textInput);