Change ClipboardMus to use mojo::SyncCallRestrictions::ScopedAllowSyncCall.

ui/views/mus/clipboard_mus.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/mus/clipboard_mus.h"
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_restrictions.h"
 #include "mojo/common/common_type_converters.h"
+#include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 #include "services/shell/public/cpp/connector.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace views {
 namespace {
 
 mus::mojom::Clipboard::Type GetType(ui::ClipboardType type) {
   switch (type) {
@@ skipping 53 matching lines @@
   // connection.
   return format.Serialize();
 }
 
 bool ClipboardMus::HasMimeType(const mojo::Array<mojo::String>& available_types,
                                const std::string& type) const {
   return ContainsValue(available_types, type);
 }
 
 uint64_t ClipboardMus::GetSequenceNumber(ui::ClipboardType type) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   uint64_t sequence_number = 0;
   clipboard_->GetSequenceNumber(GetType(type), &sequence_number);
   return sequence_number;
 }
 
 bool ClipboardMus::IsFormatAvailable(const FormatType& format,
                                      ui::ClipboardType type) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
 
   uint64_t sequence_number = 0;
   mojo::Array<mojo::String> available_types;
   clipboard_->GetAvailableMimeTypes(GetType(type), &sequence_number,
                                     &available_types);
 
   mojo::String format_in_mime = GetMimeTypeFor(format);
   return ContainsValue(available_types, format_in_mime);
 }
 
 void ClipboardMus::Clear(ui::ClipboardType type) {
   // Sends the data to mus server.
   uint64_t sequence_number = 0;
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   clipboard_->WriteClipboardData(GetType(type), nullptr,
                                  &sequence_number);
 }
 
 void ClipboardMus::ReadAvailableTypes(ui::ClipboardType type,
                                       std::vector<base::string16>* types,
                                       bool* contains_filenames) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
 
   uint64_t sequence_number = 0;
   mojo::Array<mojo::String> available_types;
   clipboard_->GetAvailableMimeTypes(GetType(type), &sequence_number,
                                     &available_types);
 
   types->clear();
   if (HasMimeType(available_types, mus::mojom::kMimeTypeText))
     types->push_back(base::UTF8ToUTF16(mus::mojom::kMimeTypeText));
   if (HasMimeType(available_types, mus::mojom::kMimeTypeHTML))
@@ skipping 10 matching lines @@
                                       &sequence_number, &custom_data)) {
       ui::ReadCustomDataTypes(&custom_data.front(), custom_data.size(), types);
     }
   }
 
   *contains_filenames = false;
 }
 
 void ClipboardMus::ReadText(ui::ClipboardType type,
                             base::string16* result) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> text_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type),
                                     mojo::String(mus::mojom::kMimeTypeText),
                                     &sequence_number, &text_data)) {
     std::string text = text_data.To<std::string>();
     *result = base::UTF8ToUTF16(text);
   }
 }
 
 void ClipboardMus::ReadAsciiText(ui::ClipboardType type,
                                  std::string* result) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> text_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type),
                                     mojo::String(mus::mojom::kMimeTypeText),
                                     &sequence_number, &text_data)) {
     *result = text_data.To<std::string>();
   }
 }
 
 void ClipboardMus::ReadHTML(ui::ClipboardType type,
                             base::string16* markup,
                             std::string* src_url,
                             uint32_t* fragment_start,
                             uint32_t* fragment_end) const {
   markup->clear();
   if (src_url)
     src_url->clear();
   *fragment_start = 0;
   *fragment_end = 0;
 
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> html_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type),
                                     mojo::String(mus::mojom::kMimeTypeHTML),
                                     &sequence_number, &html_data)) {
     *markup = base::UTF8ToUTF16(html_data.To<std::string>());
     *fragment_end = static_cast<uint32_t>(markup->length());
 
     // We only bother fetching the source url if we were the ones who wrote
     // this html data to the clipboard.
     mojo::Array<uint8_t> url_data;
     if (clipboard_->ReadClipboardData(GetType(type), kInternalSourceURL,
                                       &sequence_number, &url_data)) {
       *src_url = url_data.To<std::string>();
     }
   }
 }
 
 void ClipboardMus::ReadRTF(ui::ClipboardType type, std::string* result) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> rtf_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(
           GetType(type), mojo::String(mus::mojom::kMimeTypeRTF),
           &sequence_number, &rtf_data)) {
     *result = rtf_data.To<std::string>();
   }
 }
 
 SkBitmap ClipboardMus::ReadImage(ui::ClipboardType type) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(
           GetType(type), mojo::String(mus::mojom::kMimeTypePNG),
           &sequence_number, &data)) {
     SkBitmap bitmap;
     if (gfx::PNGCodec::Decode(&data.front(), data.size(), &bitmap))
       return SkBitmap(bitmap);
   }
 
   return SkBitmap();
 }
 
 void ClipboardMus::ReadCustomData(ui::ClipboardType clipboard_type,
                                   const base::string16& type,
                                   base::string16* result) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> custom_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(clipboard_type),
                                     mojo::String(kMimeTypeWebCustomData),
                                     &sequence_number, &custom_data)) {
     ui::ReadCustomDataForType(&custom_data.front(), custom_data.size(), type,
                               result);
   }
 }
 
 void ClipboardMus::ReadBookmark(base::string16* title, std::string* url) const {
   // TODO(erg): This is NOTIMPLEMENTED() on all linux platforms?
   NOTIMPLEMENTED();
 }
 
 void ClipboardMus::ReadData(const FormatType& format,
                             std::string* result) const {
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   mojo::Array<uint8_t> data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(mus::mojom::Clipboard::Type::COPY_PASTE,
                                     GetMimeTypeFor(format),
                                     &sequence_number, &data)) {
     *result = data.To<std::string>();
   }
 }
 
 void ClipboardMus::WriteObjects(ui::ClipboardType type,
                                 const ObjectMap& objects) {
   current_clipboard_.reset(new mojo::Map<mojo::String, mojo::Array<uint8_t>>);
   for (const auto& p : objects)
     DispatchObject(static_cast<ObjectType>(p.first), p.second);
 
   // Sends the data to mus server.
   uint64_t sequence_number = 0;
-  base::ThreadRestrictions::ScopedAllowWait allow_wait;
+  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   clipboard_->WriteClipboardData(GetType(type), std::move(*current_clipboard_),
                                  &sequence_number);
   current_clipboard_.reset();
 }
 
 void ClipboardMus::WriteText(const char* text_data, size_t text_len) {
   DCHECK(current_clipboard_);
   current_clipboard_->insert(
       mus::mojom::kMimeTypeText,
       mojo::Array<uint8_t>::From(base::StringPiece(text_data, text_len)));
@@ skipping 54 matching lines @@
 void ClipboardMus::WriteData(const FormatType& format,
                              const char* data_data,
                              size_t data_len) {
   DCHECK(current_clipboard_);
   current_clipboard_->insert(
       GetMimeTypeFor(format),
       mojo::Array<uint8_t>::From(base::StringPiece(data_data, data_len)));
 }
 
 }  // namespace views