Source/WebCore/platform/Pasteboard.h

   1 /*
   2  * Copyright (C) 2006-2018 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #pragma once
  27
  28 #include "DragImage.h"
  29 #include "PasteboardItemInfo.h"
  30 #include "URL.h"
  31 #include <wtf/HashMap.h>
  32 #include <wtf/ListHashSet.h>
  33 #include <wtf/Noncopyable.h>
  34 #include <wtf/Vector.h>
  35 #include <wtf/text/WTFString.h>
  36
  37 #if PLATFORM(IOS)
  38 OBJC_CLASS NSString;
  39 #endif
  40
  41 #if PLATFORM(COCOA)
  42 OBJC_CLASS NSArray;
  43 #endif
  44
  45 #if PLATFORM(WIN)
  46 #include "COMPtr.h"
  47 #include "WCDataObject.h"
  48 #include <objidl.h>
  49 #include <windows.h>
  50 typedef struct HWND__* HWND;
  51 #endif
  52
  53 // FIXME: This class uses the DOM and makes calls to Editor.
  54 // It should be divested of its knowledge of the frame and editor.
  55
  56 namespace WebCore {
  57
  58 class DocumentFragment;
  59 class DragData;
  60 class Element;
  61 class Frame;
  62 class PasteboardStrategy;
  63 class Range;
  64 class SelectionData;
  65 class SharedBuffer;
  66
  67 enum class WebContentReadingPolicy { AnyType, OnlyRichTextTypes };
  68 enum ShouldSerializeSelectedTextForDataTransfer { DefaultSelectedTextType, IncludeImageAltTextForDataTransfer };
  69
  70 // For writing to the pasteboard. Generally sorted with the richest formats on top.
  71
  72 struct PasteboardWebContent {
  73 #if PLATFORM(COCOA)
  74     WEBCORE_EXPORT PasteboardWebContent();
  75     WEBCORE_EXPORT ~PasteboardWebContent();
  76     String contentOrigin;
  77     bool canSmartCopyOrDelete;
  78     RefPtr<SharedBuffer> dataInWebArchiveFormat;
  79     RefPtr<SharedBuffer> dataInRTFDFormat;
  80     RefPtr<SharedBuffer> dataInRTFFormat;
  81     RefPtr<SharedBuffer> dataInAttributedStringFormat;
  82     String dataInHTMLFormat;
  83     String dataInStringFormat;
  84     Vector<String> clientTypes;
  85     Vector<RefPtr<SharedBuffer>> clientData;
  86 #endif
  87 #if PLATFORM(GTK)
  88     bool canSmartCopyOrDelete;
  89     String text;
  90     String markup;
  91 #endif
  92 #if PLATFORM(WPE)
  93     String text;
  94     String markup;
  95 #endif
  96 };
  97
  98 struct PasteboardURL {
  99     URL url;
 100     String title;
 101 #if PLATFORM(MAC)
 102     String userVisibleForm;
 103 #endif
 104 #if PLATFORM(GTK)
 105     String markup;
 106 #endif
 107 };
 108
 109 struct PasteboardImage {
 110     WEBCORE_EXPORT PasteboardImage();
 111     WEBCORE_EXPORT ~PasteboardImage();
 112     RefPtr<Image> image;
 113 #if PLATFORM(MAC)
 114     RefPtr<SharedBuffer> dataInWebArchiveFormat;
 115 #endif
 116 #if !PLATFORM(WIN)
 117     PasteboardURL url;
 118 #endif
 119 #if !(PLATFORM(GTK) || PLATFORM(WIN))
 120     RefPtr<SharedBuffer> resourceData;
 121     String resourceMIMEType;
 122     Vector<String> clientTypes;
 123     Vector<RefPtr<SharedBuffer>> clientData;
 124 #endif
 125     String suggestedName;
 126     FloatSize imageSize;
 127 };
 128
 129 // For reading from the pasteboard.
 130
 131 class PasteboardWebContentReader {
 132 public:
 133     String contentOrigin;
 134
 135     virtual ~PasteboardWebContentReader() = default;
 136
 137 #if PLATFORM(COCOA)
 138     virtual bool readWebArchive(SharedBuffer&) = 0;
 139     virtual bool readFilePaths(const Vector<String>&) = 0;
 140     virtual bool readHTML(const String&) = 0;
 141     virtual bool readRTFD(SharedBuffer&) = 0;
 142     virtual bool readRTF(SharedBuffer&) = 0;
 143     virtual bool readImage(Ref<SharedBuffer>&&, const String& type) = 0;
 144     virtual bool readURL(const URL&, const String& title) = 0;
 145 #endif
 146     virtual bool readPlainText(const String&) = 0;
 147 };
 148
 149 struct PasteboardPlainText {
 150     String text;
 151 #if PLATFORM(COCOA)
 152     bool isURL;
 153 #endif
 154 };
 155
 156 struct PasteboardFileReader {
 157     virtual ~PasteboardFileReader() = default;
 158     virtual void readFilename(const String&) = 0;
 159     virtual void readBuffer(const String& filename, const String& type, Ref<SharedBuffer>&&) = 0;
 160 };
 161
 162 // FIXME: We need to ensure that the contents of sameOriginCustomData are not accessible across different origins.
 163 struct PasteboardCustomData {
 164     String origin;
 165     Vector<String> orderedTypes;
 166     HashMap<String, String> platformData;
 167     HashMap<String, String> sameOriginCustomData;
 168
 169     WEBCORE_EXPORT Ref<SharedBuffer> createSharedBuffer() const;
 170     WEBCORE_EXPORT static PasteboardCustomData fromSharedBuffer(const SharedBuffer&);
 171
 172 #if PLATFORM(COCOA)
 173     static const char* cocoaType();
 174 #endif
 175 };
 176
 177 class Pasteboard {
 178     WTF_MAKE_NONCOPYABLE(Pasteboard); WTF_MAKE_FAST_ALLOCATED;
 179 public:
 180     Pasteboard();
 181     virtual ~Pasteboard();
 182
 183 #if PLATFORM(GTK)
 184     explicit Pasteboard(const String& name);
 185     explicit Pasteboard(SelectionData&);
 186 #endif
 187
 188 #if PLATFORM(WIN)
 189     explicit Pasteboard(IDataObject*);
 190     explicit Pasteboard(WCDataObject*);
 191     explicit Pasteboard(const DragDataMap&);
 192 #endif
 193
 194     WEBCORE_EXPORT static std::unique_ptr<Pasteboard> createForCopyAndPaste();
 195
 196     static bool isSafeTypeForDOMToReadAndWrite(const String&);
 197     static bool canExposeURLToDOMWhenPasteboardContainsFiles(const String&);
 198
 199     virtual bool isStatic() const { return false; }
 200
 201     virtual WEBCORE_EXPORT bool hasData();
 202     virtual WEBCORE_EXPORT Vector<String> typesSafeForBindings(const String& origin);
 203     virtual WEBCORE_EXPORT Vector<String> typesForLegacyUnsafeBindings();
 204     virtual WEBCORE_EXPORT String readOrigin();
 205     virtual WEBCORE_EXPORT String readString(const String& type);
 206     virtual WEBCORE_EXPORT String readStringInCustomData(const String& type);
 207
 208     virtual WEBCORE_EXPORT void writeString(const String& type, const String& data);
 209     virtual WEBCORE_EXPORT void clear();
 210     virtual WEBCORE_EXPORT void clear(const String& type);
 211
 212     virtual WEBCORE_EXPORT void read(PasteboardPlainText&);
 213     virtual WEBCORE_EXPORT void read(PasteboardWebContentReader&, WebContentReadingPolicy = WebContentReadingPolicy::AnyType);
 214     virtual WEBCORE_EXPORT void read(PasteboardFileReader&);
 215
 216     virtual WEBCORE_EXPORT void write(const PasteboardURL&);
 217     virtual WEBCORE_EXPORT void writeTrustworthyWebURLsPboardType(const PasteboardURL&);
 218     virtual WEBCORE_EXPORT void write(const PasteboardImage&);
 219     virtual WEBCORE_EXPORT void write(const PasteboardWebContent&);
 220
 221     virtual WEBCORE_EXPORT void writeCustomData(const PasteboardCustomData&);
 222
 223     virtual WEBCORE_EXPORT bool containsFiles();
 224     virtual WEBCORE_EXPORT bool canSmartReplace();
 225
 226     virtual WEBCORE_EXPORT void writeMarkup(const String& markup);
 227     enum SmartReplaceOption { CanSmartReplace, CannotSmartReplace };
 228     virtual WEBCORE_EXPORT void writePlainText(const String&, SmartReplaceOption); // FIXME: Two separate functions would be clearer than one function with an argument.
 229
 230 #if ENABLE(DRAG_SUPPORT)
 231     WEBCORE_EXPORT static std::unique_ptr<Pasteboard> createForDragAndDrop();
 232     WEBCORE_EXPORT static std::unique_ptr<Pasteboard> createForDragAndDrop(const DragData&);
 233
 234     virtual void setDragImage(DragImage, const IntPoint& hotSpot);
 235 #endif
 236
 237 #if PLATFORM(WIN)
 238     RefPtr<DocumentFragment> documentFragment(Frame&, Range&, bool allowPlainText, bool& chosePlainText); // FIXME: Layering violation.
 239     void writeImage(Element&, const URL&, const String& title); // FIXME: Layering violation.
 240     void writeSelection(Range&, bool canSmartCopyOrDelete, Frame&, ShouldSerializeSelectedTextForDataTransfer = DefaultSelectedTextType); // FIXME: Layering violation.
 241 #endif
 242
 243 #if PLATFORM(GTK)
 244     const SelectionData& selectionData() const;
 245     static std::unique_ptr<Pasteboard> createForGlobalSelection();
 246 #endif
 247
 248 #if PLATFORM(IOS)
 249     explicit Pasteboard(long changeCount);
 250     explicit Pasteboard(const String& pasteboardName);
 251
 252     static NSArray *supportedWebContentPasteboardTypes();
 253     static String resourceMIMEType(NSString *mimeType);
 254 #endif
 255
 256 #if PLATFORM(MAC)
 257     explicit Pasteboard(const String& pasteboardName, const Vector<String>& promisedFilePaths = { });
 258 #endif
 259
 260 #if PLATFORM(COCOA)
 261     static bool shouldTreatCocoaTypeAsFile(const String&);
 262     WEBCORE_EXPORT static NSArray *supportedFileUploadPasteboardTypes();
 263     const String& name() const { return m_pasteboardName; }
 264     long changeCount() const;
 265     const PasteboardCustomData& readCustomData();
 266 #endif
 267
 268 #if PLATFORM(WIN)
 269     COMPtr<IDataObject> dataObject() const { return m_dataObject; }
 270     void setExternalDataObject(IDataObject*);
 271     const DragDataMap& dragDataMap() const { return m_dragDataMap; }
 272     void writeURLToWritableDataObject(const URL&, const String&);
 273     COMPtr<WCDataObject> writableDataObject() const { return m_writableDataObject; }
 274     void writeImageToDataObject(Element&, const URL&); // FIXME: Layering violation.
 275 #endif
 276
 277 private:
 278 #if PLATFORM(IOS)
 279     bool respectsUTIFidelities() const;
 280     void readRespectingUTIFidelities(PasteboardWebContentReader&, WebContentReadingPolicy);
 281
 282     enum class ReaderResult {
 283         ReadType,
 284         DidNotReadType,
 285         PasteboardWasChangedExternally
 286     };
 287     ReaderResult readPasteboardWebContentDataForType(PasteboardWebContentReader&, PasteboardStrategy&, NSString *type, int itemIndex);
 288 #endif
 289
 290 #if PLATFORM(WIN)
 291     void finishCreatingPasteboard();
 292     void writeRangeToDataObject(Range&, Frame&); // FIXME: Layering violation.
 293     void writeURLToDataObject(const URL&, const String&);
 294     void writePlainTextToDataObject(const String&, SmartReplaceOption);
 295 #endif
 296
 297 #if PLATFORM(COCOA)
 298     Vector<String> readFilePaths();
 299     String readPlatformValueAsString(const String& domType, long changeCount, const String& pasteboardName);
 300     static void addHTMLClipboardTypesForCocoaType(ListHashSet<String>& resultTypes, const String& cocoaType);
 301     String readStringForPlatformType(const String&);
 302     Vector<String> readTypesWithSecurityCheck();
 303     RefPtr<SharedBuffer> readBufferForTypeWithSecurityCheck(const String&);
 304 #endif
 305
 306 #if PLATFORM(GTK)
 307     void writeToClipboard();
 308     void readFromClipboard();
 309     Ref<SelectionData> m_selectionData;
 310     String m_name;
 311 #endif
 312
 313 #if PLATFORM(COCOA)
 314     String m_pasteboardName;
 315     long m_changeCount;
 316     std::optional<PasteboardCustomData> m_customDataCache;
 317 #endif
 318
 319 #if PLATFORM(MAC)
 320     Vector<String> m_promisedFilePaths;
 321 #endif
 322
 323 #if PLATFORM(WIN)
 324     HWND m_owner;
 325     COMPtr<IDataObject> m_dataObject;
 326     COMPtr<WCDataObject> m_writableDataObject;
 327     DragDataMap m_dragDataMap;
 328 #endif
 329 };
 330
 331 #if PLATFORM(IOS)
 332 extern NSString *WebArchivePboardType;
 333 #endif
 334
 335 #if PLATFORM(MAC)
 336 extern const char* const WebArchivePboardType;
 337 extern const char* const WebURLNamePboardType;
 338 #endif
 339
 340 #if !PLATFORM(GTK)
 341
 342 inline Pasteboard::~Pasteboard()
 343 {
 344 }
 345
 346 #endif
 347
 348 } // namespace WebCore