path: root/chromium/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/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 {

ui::mojom::Clipboard::Type GetType(ui::ClipboardType type) {
  switch (type) {
    case ui::CLIPBOARD_TYPE_COPY_PASTE:
      return ui::mojom::Clipboard::Type::COPY_PASTE;
    case ui::CLIPBOARD_TYPE_SELECTION:
      return ui::mojom::Clipboard::Type::SELECTION;
    case ui::CLIPBOARD_TYPE_DRAG:
      // Only OSX uses a drag clipboard.
      break;
  }

  NOTREACHED();
  return ui::mojom::Clipboard::Type::COPY_PASTE;
}

// The source URL of copied HTML.
const char kInternalSourceURL[] = "chromium/internal-url";

}  // namespace

ClipboardMus::ClipboardMus() {}

ClipboardMus::~ClipboardMus() {}

void ClipboardMus::Init(service_manager::Connector* connector) {
  connector->BindInterface(ui::mojom::kServiceName, &clipboard_);
}

// TODO(erg): This isn't optimal. It would be better to move the entire
// FormatType system to mime types throughout chrome, but that's a very large
// change.
std::string ClipboardMus::GetMimeTypeFor(const FormatType& format) {
  if (format.Equals(GetUrlFormatType()) || format.Equals(GetUrlWFormatType()))
    return ui::mojom::kMimeTypeURIList;
  if (format.Equals(GetMozUrlFormatType()))
    return ui::mojom::kMimeTypeMozillaURL;
  if (format.Equals(GetPlainTextFormatType()) ||
      format.Equals(GetPlainTextWFormatType())) {
    return ui::mojom::kMimeTypeText;
  }
  if (format.Equals(GetHtmlFormatType()))
    return ui::mojom::kMimeTypeHTML;
  if (format.Equals(GetRtfFormatType()))
    return ui::mojom::kMimeTypeRTF;
  if (format.Equals(GetBitmapFormatType()))
    return ui::mojom::kMimeTypePNG;
  if (format.Equals(GetWebKitSmartPasteFormatType()))
    return kMimeTypeWebkitSmartPaste;
  if (format.Equals(GetWebCustomDataFormatType()))
    return kMimeTypeWebCustomData;
  if (format.Equals(GetPepperCustomDataFormatType()))
    return kMimeTypePepperCustomData;

  // TODO(erg): This isn't optimal, but it's the best we can do. On windows,
  // this will return strings that aren't MIME types, though they'll be
  // unique and should be serializable on the other side of the mojo
  // connection.
  return format.Serialize();
}

bool ClipboardMus::HasMimeType(const std::vector<std::string>& available_types,
                               const std::string& type) const {
  return base::ContainsValue(available_types, type);
}

void ClipboardMus::OnPreShutdown() {}

uint64_t ClipboardMus::GetSequenceNumber(ui::ClipboardType type) const {
  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 {
  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;

  uint64_t sequence_number = 0;
  std::vector<std::string> available_types;
  clipboard_->GetAvailableMimeTypes(GetType(type), &sequence_number,
                                    &available_types);

  std::string format_in_mime = GetMimeTypeFor(format);
  return base::ContainsValue(available_types, format_in_mime);
}

void ClipboardMus::Clear(ui::ClipboardType type) {
  // Sends the data to mus server.
  uint64_t sequence_number = 0;
  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
  clipboard_->WriteClipboardData(GetType(type), base::nullopt,
                                 &sequence_number);
}

void ClipboardMus::ReadAvailableTypes(ui::ClipboardType type,
                                      std::vector<base::string16>* types,
                                      bool* contains_filenames) const {
  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;

  uint64_t sequence_number = 0;
  std::vector<std::string> available_types;
  clipboard_->GetAvailableMimeTypes(GetType(type), &sequence_number,
                                    &available_types);

  types->clear();
  if (HasMimeType(available_types, ui::mojom::kMimeTypeText))
    types->push_back(base::UTF8ToUTF16(ui::mojom::kMimeTypeText));
  if (HasMimeType(available_types, ui::mojom::kMimeTypeHTML))
    types->push_back(base::UTF8ToUTF16(ui::mojom::kMimeTypeHTML));
  if (HasMimeType(available_types, ui::mojom::kMimeTypeRTF))
    types->push_back(base::UTF8ToUTF16(ui::mojom::kMimeTypeRTF));
  if (HasMimeType(available_types, ui::mojom::kMimeTypePNG))
    types->push_back(base::UTF8ToUTF16(ui::mojom::kMimeTypePNG));

  if (HasMimeType(available_types, kMimeTypeWebCustomData)) {
    base::Optional<std::vector<uint8_t>> custom_data;
    uint64_t sequence_number = 0;
    if (clipboard_->ReadClipboardData(GetType(type), kMimeTypeWebCustomData,
                                      &sequence_number, &custom_data) &&
        custom_data.has_value()) {
      ui::ReadCustomDataTypes(&custom_data->front(), custom_data->size(),
                              types);
    }
  }

  *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) &&
      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) &&
      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) &&
      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) &&
        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) &&
      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()) {
    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 {
  mojo::SyncCallRestrictions::ScopedAllowSyncCall allow_sync_call;
  base::Optional<std::vector<uint8_t>> custom_data;
  uint64_t sequence_number = 0;
  if (clipboard_->ReadClipboardData(GetType(clipboard_type),
                                    kMimeTypeWebCustomData, &sequence_number,
                                    &custom_data) &&
      custom_data.has_value()) {
    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 {
  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) &&
      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] =
      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] =
      std::vector<uint8_t>(markup_data, markup_data + markup_len);
  if (url_len > 0) {
    current_clipboard_.value()[kInternalSourceURL] =
        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] =
      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] =
      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] = 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)] =
      std::vector<uint8_t>(data_data, data_data + data_len);
}

}  // namespace views