Remove mojo::Array.

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 <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/sync_call_restrictions.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "services/ui/public/interfaces/constants.mojom.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 {
 
@@ skipping 123 matching lines @@
 
   *contains_filenames = false;
 }
 
 void ClipboardMus::ReadText(ui::ClipboardType type,
                             base::string16* result) const {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> text_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type), ui::mojom::kMimeTypeText,
-                                    &sequence_number, &text_data)) {
-    std::string text =
-        mojo::Array<uint8_t>(std::move(text_data)).To<std::string>();
-    *result = base::UTF8ToUTF16(text);
+                                    &sequence_number, &text_data) &&
+      text_data) {
+    *result = base::UTF8ToUTF16(base::StringPiece(
+        reinterpret_cast<char*>(text_data->data()), text_data->size()));
   }
 }
 
 void ClipboardMus::ReadAsciiText(ui::ClipboardType type,
                                  std::string* result) const {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> text_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type), ui::mojom::kMimeTypeText,
-                                    &sequence_number, &text_data)) {
-    *result = mojo::Array<uint8_t>(std::move(text_data)).To<std::string>();
+                                    &sequence_number, &text_data) &&
+      text_data) {
+    result->assign(text_data->begin(), text_data->end());
   }
 }
 
 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;
 
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> html_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type), ui::mojom::kMimeTypeHTML,
-                                    &sequence_number, &html_data)) {
-    *markup = base::UTF8ToUTF16(
-        mojo::Array<uint8_t>(std::move(html_data)).To<std::string>());
+                                    &sequence_number, &html_data) &&
+      html_data) {
+    *markup = base::UTF8ToUTF16(base::StringPiece(
+        reinterpret_cast<char*>(html_data->data()), html_data->size()));
     *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.
     base::Optional<std::vector<uint8_t>> url_data;
     if (clipboard_->ReadClipboardData(GetType(type), kInternalSourceURL,
-                                      &sequence_number, &url_data)) {
-      *src_url = mojo::Array<uint8_t>(std::move(url_data)).To<std::string>();
+                                      &sequence_number, &url_data) &&
+        url_data) {
+      src_url->assign(url_data->begin(), url_data->end());
     }
   }
 }
 
 void ClipboardMus::ReadRTF(ui::ClipboardType type, std::string* result) const {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> rtf_data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type), ui::mojom::kMimeTypeRTF,
-                                    &sequence_number, &rtf_data)) {
-    *result = mojo::Array<uint8_t>(std::move(rtf_data)).To<std::string>();
+                                    &sequence_number, &rtf_data) &&
+      rtf_data) {
+    result->assign(rtf_data->begin(), rtf_data->end());
   }
 }
 
 SkBitmap ClipboardMus::ReadImage(ui::ClipboardType type) const {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(GetType(type), ui::mojom::kMimeTypePNG,
                                     &sequence_number, &data) &&
       data.has_value()) {
@@ skipping 25 matching lines @@
   NOTIMPLEMENTED();
 }
 
 void ClipboardMus::ReadData(const FormatType& format,
                             std::string* result) const {
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   base::Optional<std::vector<uint8_t>> data;
   uint64_t sequence_number = 0;
   if (clipboard_->ReadClipboardData(ui::mojom::Clipboard::Type::COPY_PASTE,
                                     GetMimeTypeFor(format), &sequence_number,
-                                    &data)) {
-    *result = mojo::Array<uint8_t>(std::move(data)).To<std::string>();
+                                    &data) &&
+      data) {
+    result->assign(data->begin(), data->end());
   }
 }
 
 void ClipboardMus::WriteObjects(ui::ClipboardType type,
                                 const ObjectMap& objects) {
   current_clipboard_.emplace();
   for (const auto& p : objects)
     DispatchObject(static_cast<ObjectType>(p.first), p.second);
 
   // Sends the data to mus server.
   uint64_t sequence_number = 0;
   mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
   clipboard_->WriteClipboardData(GetType(type), std::move(current_clipboard_),
                                  &sequence_number);
 }
 
 void ClipboardMus::WriteText(const char* text_data, size_t text_len) {
   DCHECK(current_clipboard_);
   current_clipboard_.value()[ui::mojom::kMimeTypeText] =
-      mojo::Array<uint8_t>::From(base::StringPiece(text_data, text_len))
-          .PassStorage();
+      std::vector<uint8_t>(text_data, text_data + text_len);
 }
 
 void ClipboardMus::WriteHTML(const char* markup_data,
                              size_t markup_len,
                              const char* url_data,
                              size_t url_len) {
   DCHECK(current_clipboard_);
   current_clipboard_.value()[ui::mojom::kMimeTypeHTML] =
-      mojo::Array<uint8_t>::From(base::StringPiece(markup_data, markup_len))
-          .PassStorage();
+      std::vector<uint8_t>(markup_data, markup_data + markup_len);
   if (url_len > 0) {
     current_clipboard_.value()[kInternalSourceURL] =
-        mojo::Array<uint8_t>::From(base::StringPiece(url_data, url_len))
-            .PassStorage();
+        std::vector<uint8_t>(url_data, url_data + url_len);
   }
 }
 
 void ClipboardMus::WriteRTF(const char* rtf_data, size_t data_len) {
   DCHECK(current_clipboard_);
   current_clipboard_.value()[ui::mojom::kMimeTypeRTF] =
-      mojo::Array<uint8_t>::From(base::StringPiece(rtf_data, data_len))
-          .PassStorage();
+      std::vector<uint8_t>(rtf_data, rtf_data + data_len);
 }
 
 void ClipboardMus::WriteBookmark(const char* title_data,
                                  size_t title_len,
                                  const char* url_data,
                                  size_t url_len) {
   // Writes a Mozilla url (UTF16: URL, newline, title)
   base::string16 bookmark =
       base::UTF8ToUTF16(base::StringPiece(url_data, url_len)) +
       base::ASCIIToUTF16("\n") +
       base::UTF8ToUTF16(base::StringPiece(title_data, title_len));
 
   DCHECK(current_clipboard_);
   current_clipboard_.value()[ui::mojom::kMimeTypeMozillaURL] =
-      mojo::Array<uint8_t>::From(bookmark).PassStorage();
+      std::vector<uint8_t>(
+          reinterpret_cast<const uint8_t*>(bookmark.data()),
+          reinterpret_cast<const uint8_t*>(bookmark.data() + bookmark.size()));
 }
 
 void ClipboardMus::WriteWebSmartPaste() {
   DCHECK(current_clipboard_);
   current_clipboard_.value()[kMimeTypeWebkitSmartPaste] =
       std::vector<uint8_t>();
 }
 
 void ClipboardMus::WriteBitmap(const SkBitmap& bitmap) {
   DCHECK(current_clipboard_);
   // Encode the bitmap as a PNG for transport.
   std::vector<unsigned char> output;
   if (gfx::PNGCodec::FastEncodeBGRASkBitmap(bitmap, false, &output)) {
-    current_clipboard_.value()[ui::mojom::kMimeTypePNG] =
-        mojo::Array<uint8_t>::From(output).PassStorage();
+    current_clipboard_.value()[ui::mojom::kMimeTypePNG] = std::move(output);
   }
 }
 
 void ClipboardMus::WriteData(const FormatType& format,
                              const char* data_data,
                              size_t data_len) {
   DCHECK(current_clipboard_);
   current_clipboard_.value()[GetMimeTypeFor(format)] =
-      mojo::Array<uint8_t>::From(base::StringPiece(data_data, data_len))
-          .PassStorage();
+      std::vector<uint8_t>(data_data, data_data + data_len);
 }
 
 }  // namespace views