widget/headless/HeadlessClipboard.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this
   3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include "HeadlessClipboard.h"
   6
   7 #include "nsISupportsPrimitives.h"
   8 #include "nsComponentManagerUtils.h"
   9 #include "nsCOMPtr.h"
  10
  11 namespace mozilla::widget {
  12
  13 NS_IMPL_ISUPPORTS_INHERITED0(HeadlessClipboard, nsBaseClipboard)
  14
  15 HeadlessClipboard::HeadlessClipboard()
  16     : nsBaseClipboard(mozilla::dom::ClipboardCapabilities(
  17           true /* supportsSelectionClipboard */,
  18           true /* supportsFindClipboard */,
  19           true /* supportsSelectionCache */)) {
  20   for (auto& clipboard : mClipboards) {
  21     clipboard = MakeUnique<HeadlessClipboardData>();
  22   }
  23 }
  24
  25 NS_IMETHODIMP
  26 HeadlessClipboard::SetNativeClipboardData(nsITransferable* aTransferable,
  27                                           int32_t aWhichClipboard) {
  28   MOZ_DIAGNOSTIC_ASSERT(aTransferable);
  29   MOZ_DIAGNOSTIC_ASSERT(
  30       nsIClipboard::IsClipboardTypeSupported(aWhichClipboard));
  31
  32   // Clear out the clipboard in order to set the new data.
  33   EmptyNativeClipboardData(aWhichClipboard);
  34
  35   nsTArray<nsCString> flavors;
  36   nsresult rv = aTransferable->FlavorsTransferableCanExport(flavors);
  37   if (NS_FAILED(rv)) {
  38     return rv;
  39   }
  40
  41   auto& clipboard = mClipboards[aWhichClipboard];
  42   MOZ_ASSERT(clipboard);
  43
  44   for (const auto& flavor : flavors) {
  45     if (!flavor.EqualsLiteral(kTextMime) && !flavor.EqualsLiteral(kHTMLMime)) {
  46       continue;
  47     }
  48
  49     nsCOMPtr<nsISupports> data;
  50     rv = aTransferable->GetTransferData(flavor.get(), getter_AddRefs(data));
  51     if (NS_FAILED(rv)) {
  52       continue;
  53     }
  54
  55     nsCOMPtr<nsISupportsString> wideString = do_QueryInterface(data);
  56     if (!wideString) {
  57       continue;
  58     }
  59
  60     nsAutoString utf16string;
  61     wideString->GetData(utf16string);
  62     flavor.EqualsLiteral(kTextMime) ? clipboard->SetText(utf16string)
  63                                     : clipboard->SetHTML(utf16string);
  64   }
  65
  66   return NS_OK;
  67 }
  68
  69 NS_IMETHODIMP
  70 HeadlessClipboard::GetNativeClipboardData(nsITransferable* aTransferable,
  71                                           int32_t aWhichClipboard) {
  72   MOZ_DIAGNOSTIC_ASSERT(aTransferable);
  73   MOZ_DIAGNOSTIC_ASSERT(
  74       nsIClipboard::IsClipboardTypeSupported(aWhichClipboard));
  75
  76   nsTArray<nsCString> flavors;
  77   nsresult rv = aTransferable->FlavorsTransferableCanImport(flavors);
  78   if (NS_FAILED(rv)) {
  79     return NS_ERROR_FAILURE;
  80   }
  81
  82   auto& clipboard = mClipboards[aWhichClipboard];
  83   MOZ_ASSERT(clipboard);
  84
  85   for (const auto& flavor : flavors) {
  86     if (!flavor.EqualsLiteral(kTextMime) && !flavor.EqualsLiteral(kHTMLMime)) {
  87       continue;
  88     }
  89
  90     bool isText = flavor.EqualsLiteral(kTextMime);
  91     if (!(isText ? clipboard->HasText() : clipboard->HasHTML())) {
  92       continue;
  93     }
  94
  95     nsCOMPtr<nsISupportsString> dataWrapper =
  96         do_CreateInstance(NS_SUPPORTS_STRING_CONTRACTID, &rv);
  97     rv = dataWrapper->SetData(isText ? clipboard->GetText()
  98                                      : clipboard->GetHTML());
  99     if (NS_WARN_IF(NS_FAILED(rv))) {
 100       continue;
 101     }
 102
 103     nsCOMPtr<nsISupports> genericDataWrapper = do_QueryInterface(dataWrapper);
 104     rv = aTransferable->SetTransferData(flavor.get(), genericDataWrapper);
 105     if (NS_WARN_IF(NS_FAILED(rv))) {
 106       continue;
 107     }
 108
 109     // XXX Other platforms only fill the first available type, too.
 110     break;
 111   }
 112
 113   return NS_OK;
 114 }
 115
 116 nsresult HeadlessClipboard::EmptyNativeClipboardData(int32_t aWhichClipboard) {
 117   MOZ_DIAGNOSTIC_ASSERT(
 118       nsIClipboard::IsClipboardTypeSupported(aWhichClipboard));
 119   auto& clipboard = mClipboards[aWhichClipboard];
 120   MOZ_ASSERT(clipboard);
 121   clipboard->Clear();
 122   return NS_OK;
 123 }
 124
 125 mozilla::Result<int32_t, nsresult>
 126 HeadlessClipboard::GetNativeClipboardSequenceNumber(int32_t aWhichClipboard) {
 127   MOZ_DIAGNOSTIC_ASSERT(
 128       nsIClipboard::IsClipboardTypeSupported(aWhichClipboard));
 129   auto& clipboard = mClipboards[aWhichClipboard];
 130   MOZ_ASSERT(clipboard);
 131   return clipboard->GetChangeCount();
 132   ;
 133 }
 134
 135 mozilla::Result<bool, nsresult>
 136 HeadlessClipboard::HasNativeClipboardDataMatchingFlavors(
 137     const nsTArray<nsCString>& aFlavorList, int32_t aWhichClipboard) {
 138   MOZ_DIAGNOSTIC_ASSERT(
 139       nsIClipboard::IsClipboardTypeSupported(aWhichClipboard));
 140
 141   auto& clipboard = mClipboards[aWhichClipboard];
 142   MOZ_ASSERT(clipboard);
 143
 144   // Retrieve the union of all aHasType in aFlavorList
 145   for (auto& flavor : aFlavorList) {
 146     if ((flavor.EqualsLiteral(kTextMime) && clipboard->HasText()) ||
 147         (flavor.EqualsLiteral(kHTMLMime) && clipboard->HasHTML())) {
 148       return true;
 149     }
 150   }
 151   return false;
 152 }
 153
 154 }  // namespace mozilla::widget