Move flash clipboard to the new proxy and add custom format support

webkit/plugins/ppapi/ppb_flash_impl.cc

 // Copyright (c) 2012 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 "webkit/plugins/ppapi/ppb_flash_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/message_loop.h"
@@ skipping 14 matching lines @@
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkTemplates.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebDocument.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebElement.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebPluginContainer.h"
 #include "ui/gfx/rect.h"
-#include "webkit/glue/clipboard_client.h"
-#include "webkit/glue/scoped_clipboard_writer_glue.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/host_globals.h"
 #include "webkit/plugins/ppapi/plugin_delegate.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_file_ref_impl.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 #include "webkit/plugins/ppapi/ppb_image_data_impl.h"
 
 using ppapi::PPTimeToTime;
 using ppapi::StringVar;
 using ppapi::TimeToPPTime;
 using ppapi::thunk::EnterResource;
 using ppapi::thunk::EnterResourceNoLock;
 using ppapi::thunk::PPB_FileRef_API;
 using ppapi::thunk::PPB_ImageData_API;
 using ppapi::thunk::PPB_URLRequestInfo_API;
 
 namespace webkit {
 namespace ppapi {
 
-namespace {
-
-const size_t kMaxClipboardWriteSize = 1000000;
-
-ui::Clipboard::Buffer ConvertClipboardType(
-    PP_Flash_Clipboard_Type type) {
-  switch (type) {
-    case PP_FLASH_CLIPBOARD_TYPE_STANDARD:
-      return ui::Clipboard::BUFFER_STANDARD;
-    case PP_FLASH_CLIPBOARD_TYPE_SELECTION:
-      return ui::Clipboard::BUFFER_SELECTION;
-  }
-  NOTREACHED();
-  return ui::Clipboard::BUFFER_STANDARD;
-}
-
-}  // namespace
-
 PPB_Flash_Impl::PPB_Flash_Impl(PluginInstance* instance)
     : instance_(instance) {
 }
 
 PPB_Flash_Impl::~PPB_Flash_Impl() {
 }
 
 void PPB_Flash_Impl::SetInstanceAlwaysOnTop(PP_Instance instance,
                                             PP_Bool on_top) {
   instance_->set_always_on_top(PP_ToBool(on_top));
@@ skipping 185 matching lines @@
   }
 }
 
 PP_Bool PPB_Flash_Impl::SetCrashData(PP_Instance instance,
                                      PP_FlashCrashKey key,
                                      PP_Var value) {
   // Not implemented in process.
   return PP_FALSE;
 }
 
-
-PP_Bool PPB_Flash_Impl::IsClipboardFormatAvailable(
-    PP_Instance instance,
-    PP_Flash_Clipboard_Type clipboard_type,
-    PP_Flash_Clipboard_Format format) {
-  if (!InitClipboard())
-    return PP_FALSE;
-
-  if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
-    NOTIMPLEMENTED();
-    return PP_FALSE;
-  }
-
-  ui::Clipboard::Buffer buffer_type = ConvertClipboardType(clipboard_type);
-  switch (format) {
-    case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: {
-      bool plain = clipboard_client_->IsFormatAvailable(
-          ui::Clipboard::GetPlainTextFormatType(), buffer_type);
-      bool plainw = clipboard_client_->IsFormatAvailable(
-          ui::Clipboard::GetPlainTextWFormatType(), buffer_type);
-      return BoolToPPBool(plain || plainw);
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_HTML:
-      return BoolToPPBool(clipboard_client_->IsFormatAvailable(
-          ui::Clipboard::GetHtmlFormatType(), buffer_type));
-    case PP_FLASH_CLIPBOARD_FORMAT_RTF:
-      return BoolToPPBool(clipboard_client_->IsFormatAvailable(
-          ui::Clipboard::GetRtfFormatType(), buffer_type));
-    case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
-      break;
-  }
-
-  return PP_FALSE;
-}
-
-PP_Var PPB_Flash_Impl::ReadClipboardData(
-    PP_Instance instance,
-    PP_Flash_Clipboard_Type clipboard_type,
-    PP_Flash_Clipboard_Format format) {
-  if (!InitClipboard())
-    return PP_MakeUndefined();
-
-  if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
-    NOTIMPLEMENTED();
-    return PP_MakeUndefined();
-  }
-
-  if (!IsClipboardFormatAvailable(instance, clipboard_type, format))
-    return PP_MakeNull();
-
-  ui::Clipboard::Buffer buffer_type = ConvertClipboardType(clipboard_type);
-
-  switch (format) {
-    case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: {
-      if (clipboard_client_->IsFormatAvailable(
-              ui::Clipboard::GetPlainTextWFormatType(), buffer_type)) {
-        string16 text;
-        clipboard_client_->ReadText(buffer_type, &text);
-        if (!text.empty())
-          return StringVar::StringToPPVar(UTF16ToUTF8(text));
-      }
-
-      if (clipboard_client_->IsFormatAvailable(
-              ui::Clipboard::GetPlainTextFormatType(), buffer_type)) {
-        std::string text;
-        clipboard_client_->ReadAsciiText(buffer_type, &text);
-        if (!text.empty())
-          return StringVar::StringToPPVar(text);
-      }
-
-      return PP_MakeNull();
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_HTML: {
-      string16 html;
-      GURL gurl;
-      uint32 fragment_start;
-      uint32 fragment_end;
-      clipboard_client_->ReadHTML(buffer_type,
-                                  &html,
-                                  &gurl,
-                                  &fragment_start,
-                                  &fragment_end);
-      return StringVar::StringToPPVar(UTF16ToUTF8(
-          html.substr(fragment_start, fragment_end - fragment_start)));
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_RTF: {
-      std::string result;
-      clipboard_client_->ReadRTF(buffer_type, &result);
-      return ::ppapi::PpapiGlobals::Get()->GetVarTracker()->
-          MakeArrayBufferPPVar(result.size(), result.data());
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
-      break;
-  }
-
-  return PP_MakeUndefined();
-}
-
-int32_t PPB_Flash_Impl::WriteClipboardData(
-    PP_Instance instance,
-    PP_Flash_Clipboard_Type clipboard_type,
-    uint32_t data_item_count,
-    const PP_Flash_Clipboard_Format formats[],
-    const PP_Var data_items[]) {
-  if (!InitClipboard())
-    return PP_ERROR_FAILED;
-
-  if (clipboard_type != PP_FLASH_CLIPBOARD_TYPE_STANDARD) {
-    NOTIMPLEMENTED();
-    return PP_ERROR_FAILED;
-  }
-
-  if (data_item_count == 0) {
-    clipboard_client_->Clear(ConvertClipboardType(clipboard_type));
-    return PP_OK;
-  }
-  ScopedClipboardWriterGlue scw(clipboard_client_.get());
-  for (uint32_t i = 0; i < data_item_count; ++i) {
-    int32_t res = WriteClipboardDataItem(formats[i], data_items[i], &scw);
-    if (res != PP_OK) {
-      // Need to clear the objects so nothing is written.
-      scw.Reset();
-      return res;
-    }
-  }
-
-  return PP_OK;
-}
-
 bool PPB_Flash_Impl::CreateThreadAdapterForInstance(PP_Instance instance) {
   return false;  // No multithreaded access allowed.
 }
 
 void PPB_Flash_Impl::ClearThreadAdapterForInstance(PP_Instance instance) {
 }
 
 int32_t PPB_Flash_Impl::OpenFile(PP_Instance pp_instance,
                                  const char* path,
                                  int32_t mode,
@@ skipping 215 matching lines @@
                                            PP_Bool fullscreen) {
   instance_->FlashSetFullscreen(PP_ToBool(fullscreen), true);
   return PP_TRUE;
 }
 
 PP_Bool PPB_Flash_Impl::FlashGetScreenSize(PP_Instance instance,
                                            PP_Size* size) {
   return instance_->GetScreenSize(instance, size);
 }
 
-bool PPB_Flash_Impl::InitClipboard() {
-  // Initialize the ClipboardClient for writing to the clipboard.
-  if (!clipboard_client_.get()) {
-    if (!instance_)
-      return false;
-    PluginDelegate* plugin_delegate = instance_->delegate();
-    if (!plugin_delegate)
-      return false;
-    clipboard_client_.reset(plugin_delegate->CreateClipboardClient());
-  }
-  return true;
-}
-
-int32_t PPB_Flash_Impl::WriteClipboardDataItem(
-    const PP_Flash_Clipboard_Format format,
-    const PP_Var& data,
-    ScopedClipboardWriterGlue* scw) {
-  switch (format) {
-    case PP_FLASH_CLIPBOARD_FORMAT_PLAINTEXT: {
-      StringVar* text_string = StringVar::FromPPVar(data);
-      if (!text_string)
-        return PP_ERROR_BADARGUMENT;
-
-      if (text_string->value().length() > kMaxClipboardWriteSize)
-        return PP_ERROR_NOSPACE;
-
-      scw->WriteText(UTF8ToUTF16(text_string->value()));
-      return PP_OK;
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_HTML: {
-      StringVar* text_string = StringVar::FromPPVar(data);
-      if (!text_string)
-        return PP_ERROR_BADARGUMENT;
-
-      if (text_string->value().length() > kMaxClipboardWriteSize)
-        return PP_ERROR_NOSPACE;
-
-      scw->WriteHTML(UTF8ToUTF16(text_string->value()), "");
-      return PP_OK;
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_RTF: {
-      ::ppapi::ArrayBufferVar* rtf_data =
-          ::ppapi::ArrayBufferVar::FromPPVar(data);
-      if (!rtf_data)
-        return PP_ERROR_BADARGUMENT;
-
-      if (rtf_data->ByteLength() > kMaxClipboardWriteSize)
-        return PP_ERROR_NOSPACE;
-
-      scw->WriteRTF(std::string(static_cast<char*>(rtf_data->Map()),
-                                rtf_data->ByteLength()));
-      return PP_OK;
-    }
-    case PP_FLASH_CLIPBOARD_FORMAT_INVALID:
-      break;
-  }
-
-  return PP_ERROR_BADARGUMENT;
-}
-
 }  // namespace ppapi
 }  // namespace webkit