ui/base/clipboard/clipboard_util_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/base/clipboard/clipboard_util_win.h"
   6
   7 #include <shellapi.h>
   8 #include <shlwapi.h>
   9 #include <wininet.h>  // For INTERNET_MAX_URL_LENGTH.
  10
  11 #include "base/basictypes.h"
  12 #include "base/logging.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/sys_string_conversions.h"
  16 #include "base/strings/utf_string_conversions.h"
  17 #include "base/win/scoped_hglobal.h"
  18 #include "net/base/filename_util.h"
  19 #include "ui/base/clipboard/clipboard.h"
  20 #include "ui/base/clipboard/custom_data_helper.h"
  21 #include "url/gurl.h"
  22
  23 namespace ui {
  24
  25 namespace {
  26
  27 bool HasData(IDataObject* data_object, const Clipboard::FormatType& format) {
  28   FORMATETC format_etc = format.ToFormatEtc();
  29   return SUCCEEDED(data_object->QueryGetData(&format_etc));
  30 }
  31
  32 bool GetData(IDataObject* data_object,
  33              const Clipboard::FormatType& format,
  34              STGMEDIUM* medium) {
  35   FORMATETC format_etc = format.ToFormatEtc();
  36   return SUCCEEDED(data_object->GetData(&format_etc, medium));
  37 }
  38
  39 bool GetUrlFromHDrop(IDataObject* data_object,
  40                      GURL* url,
  41                      base::string16* title) {
  42   DCHECK(data_object && url && title);
  43
  44   bool success = false;
  45   STGMEDIUM medium;
  46   if (!GetData(data_object, Clipboard::GetCFHDropFormatType(), &medium))
  47     return false;
  48
  49   {
  50     base::win::ScopedHGlobal<HDROP> hdrop(medium.hGlobal);
  51
  52     if (!hdrop.get())
  53       return false;
  54
  55     wchar_t filename[MAX_PATH];
  56     if (DragQueryFileW(hdrop.get(), 0, filename, arraysize(filename))) {
  57       wchar_t url_buffer[INTERNET_MAX_URL_LENGTH];
  58       if (0 == _wcsicmp(PathFindExtensionW(filename), L".url") &&
  59           GetPrivateProfileStringW(L"InternetShortcut",
  60                                    L"url",
  61                                    0,
  62                                    url_buffer,
  63                                    arraysize(url_buffer),
  64                                    filename)) {
  65         *url = GURL(url_buffer);
  66         PathRemoveExtension(filename);
  67         title->assign(PathFindFileName(filename));
  68         success = url->is_valid();
  69       }
  70     }
  71   }
  72
  73   ReleaseStgMedium(&medium);
  74   return success;
  75 }
  76
  77 void SplitUrlAndTitle(const base::string16& str,
  78                       GURL* url,
  79                       base::string16* title) {
  80   DCHECK(url && title);
  81   size_t newline_pos = str.find('\n');
  82   if (newline_pos != base::string16::npos) {
  83     *url = GURL(base::string16(str, 0, newline_pos));
  84     title->assign(str, newline_pos + 1, base::string16::npos);
  85   } else {
  86     *url = GURL(str);
  87     title->assign(str);
  88   }
  89 }
  90
  91 }  // namespace
  92
  93 bool ClipboardUtil::HasUrl(IDataObject* data_object, bool convert_filenames) {
  94   DCHECK(data_object);
  95   return HasData(data_object, Clipboard::GetMozUrlFormatType()) ||
  96          HasData(data_object, Clipboard::GetUrlWFormatType()) ||
  97          HasData(data_object, Clipboard::GetUrlFormatType()) ||
  98          (convert_filenames && HasFilenames(data_object));
  99 }
 100
 101 bool ClipboardUtil::HasFilenames(IDataObject* data_object) {
 102   DCHECK(data_object);
 103   return HasData(data_object, Clipboard::GetCFHDropFormatType()) ||
 104          HasData(data_object, Clipboard::GetFilenameWFormatType()) ||
 105          HasData(data_object, Clipboard::GetFilenameFormatType());
 106 }
 107
 108 bool ClipboardUtil::HasFileContents(IDataObject* data_object) {
 109   DCHECK(data_object);
 110   return HasData(data_object, Clipboard::GetFileContentZeroFormatType());
 111 }
 112
 113 bool ClipboardUtil::HasHtml(IDataObject* data_object) {
 114   DCHECK(data_object);
 115   return HasData(data_object, Clipboard::GetHtmlFormatType()) ||
 116          HasData(data_object, Clipboard::GetTextHtmlFormatType());
 117 }
 118
 119 bool ClipboardUtil::HasPlainText(IDataObject* data_object) {
 120   DCHECK(data_object);
 121   return HasData(data_object, Clipboard::GetPlainTextWFormatType()) ||
 122          HasData(data_object, Clipboard::GetPlainTextFormatType());
 123 }
 124
 125 bool ClipboardUtil::GetUrl(IDataObject* data_object,
 126                            GURL* url,
 127                            base::string16* title,
 128                            bool convert_filenames) {
 129   DCHECK(data_object && url && title);
 130   if (!HasUrl(data_object, convert_filenames))
 131     return false;
 132
 133   // Try to extract a URL from |data_object| in a variety of formats.
 134   STGMEDIUM store;
 135   if (GetUrlFromHDrop(data_object, url, title))
 136     return true;
 137
 138   if (GetData(data_object, Clipboard::GetMozUrlFormatType(), &store) ||
 139       GetData(data_object, Clipboard::GetUrlWFormatType(), &store)) {
 140     {
 141       // Mozilla URL format or unicode URL
 142       base::win::ScopedHGlobal<wchar_t*> data(store.hGlobal);
 143       SplitUrlAndTitle(data.get(), url, title);
 144     }
 145     ReleaseStgMedium(&store);
 146     return url->is_valid();
 147   }
 148
 149   if (GetData(data_object, Clipboard::GetUrlFormatType(), &store)) {
 150     {
 151       // URL using ascii
 152       base::win::ScopedHGlobal<char*> data(store.hGlobal);
 153       SplitUrlAndTitle(base::UTF8ToWide(data.get()), url, title);
 154     }
 155     ReleaseStgMedium(&store);
 156     return url->is_valid();
 157   }
 158
 159   if (convert_filenames) {
 160     std::vector<base::string16> filenames;
 161     if (!GetFilenames(data_object, &filenames))
 162       return false;
 163     DCHECK_GT(filenames.size(), 0U);
 164     *url = net::FilePathToFileURL(base::FilePath(filenames[0]));
 165     return url->is_valid();
 166   }
 167
 168   return false;
 169 }
 170
 171 bool ClipboardUtil::GetFilenames(IDataObject* data_object,
 172                                  std::vector<base::string16>* filenames) {
 173   DCHECK(data_object && filenames);
 174   if (!HasFilenames(data_object))
 175     return false;
 176
 177   STGMEDIUM medium;
 178   if (GetData(data_object, Clipboard::GetCFHDropFormatType(), &medium)) {
 179     {
 180       base::win::ScopedHGlobal<HDROP> hdrop(medium.hGlobal);
 181       if (!hdrop.get())
 182         return false;
 183
 184       const int kMaxFilenameLen = 4096;
 185       const unsigned num_files = DragQueryFileW(hdrop.get(), 0xffffffff, 0, 0);
 186       for (unsigned int i = 0; i < num_files; ++i) {
 187         wchar_t filename[kMaxFilenameLen];
 188         if (!DragQueryFileW(hdrop.get(), i, filename, kMaxFilenameLen))
 189           continue;
 190         filenames->push_back(filename);
 191       }
 192     }
 193     ReleaseStgMedium(&medium);
 194     return true;
 195   }
 196
 197   if (GetData(data_object, Clipboard::GetFilenameWFormatType(), &medium)) {
 198     {
 199       // filename using unicode
 200       base::win::ScopedHGlobal<wchar_t*> data(medium.hGlobal);
 201       if (data.get() && data.get()[0])
 202         filenames->push_back(data.get());
 203     }
 204     ReleaseStgMedium(&medium);
 205     return true;
 206   }
 207
 208   if (GetData(data_object, Clipboard::GetFilenameFormatType(), &medium)) {
 209     {
 210       // filename using ascii
 211       base::win::ScopedHGlobal<char*> data(medium.hGlobal);
 212       if (data.get() && data.get()[0])
 213         filenames->push_back(base::SysNativeMBToWide(data.get()));
 214     }
 215     ReleaseStgMedium(&medium);
 216     return true;
 217   }
 218
 219   return false;
 220 }
 221
 222 bool ClipboardUtil::GetPlainText(IDataObject* data_object,
 223                                  base::string16* plain_text) {
 224   DCHECK(data_object && plain_text);
 225   if (!HasPlainText(data_object))
 226     return false;
 227
 228   STGMEDIUM store;
 229   if (GetData(data_object, Clipboard::GetPlainTextWFormatType(), &store)) {
 230     {
 231       // Unicode text
 232       base::win::ScopedHGlobal<wchar_t*> data(store.hGlobal);
 233       plain_text->assign(data.get());
 234     }
 235     ReleaseStgMedium(&store);
 236     return true;
 237   }
 238
 239   if (GetData(data_object, Clipboard::GetPlainTextFormatType(), &store)) {
 240     {
 241       // ascii text
 242       base::win::ScopedHGlobal<char*> data(store.hGlobal);
 243       plain_text->assign(base::UTF8ToWide(data.get()));
 244     }
 245     ReleaseStgMedium(&store);
 246     return true;
 247   }
 248
 249   // If a file is dropped on the window, it does not provide either of the
 250   // plain text formats, so here we try to forcibly get a url.
 251   GURL url;
 252   base::string16 title;
 253   if (GetUrl(data_object, &url, &title, false)) {
 254     *plain_text = base::UTF8ToUTF16(url.spec());
 255     return true;
 256   }
 257   return false;
 258 }
 259
 260 bool ClipboardUtil::GetHtml(IDataObject* data_object,
 261                             base::string16* html, std::string* base_url) {
 262   DCHECK(data_object && html && base_url);
 263
 264   STGMEDIUM store;
 265   if (HasData(data_object, Clipboard::GetHtmlFormatType()) &&
 266       GetData(data_object, Clipboard::GetHtmlFormatType(), &store)) {
 267     {
 268       // MS CF html
 269       base::win::ScopedHGlobal<char*> data(store.hGlobal);
 270
 271       std::string html_utf8;
 272       CFHtmlToHtml(std::string(data.get(), data.Size()), &html_utf8, base_url);
 273       html->assign(base::UTF8ToWide(html_utf8));
 274     }
 275     ReleaseStgMedium(&store);
 276     return true;
 277   }
 278
 279   if (!HasData(data_object, Clipboard::GetTextHtmlFormatType()))
 280     return false;
 281
 282   if (!GetData(data_object, Clipboard::GetTextHtmlFormatType(), &store))
 283     return false;
 284
 285   {
 286     // text/html
 287     base::win::ScopedHGlobal<wchar_t*> data(store.hGlobal);
 288     html->assign(data.get());
 289   }
 290   ReleaseStgMedium(&store);
 291   return true;
 292 }
 293
 294 bool ClipboardUtil::GetFileContents(IDataObject* data_object,
 295     base::string16* filename, std::string* file_contents) {
 296   DCHECK(data_object && filename && file_contents);
 297   if (!HasData(data_object, Clipboard::GetFileContentZeroFormatType()) &&
 298       !HasData(data_object, Clipboard::GetFileDescriptorFormatType()))
 299     return false;
 300
 301   STGMEDIUM content;
 302   // The call to GetData can be very slow depending on what is in
 303   // |data_object|.
 304   if (GetData(
 305           data_object, Clipboard::GetFileContentZeroFormatType(), &content)) {
 306     if (TYMED_HGLOBAL == content.tymed) {
 307       base::win::ScopedHGlobal<char*> data(content.hGlobal);
 308       file_contents->assign(data.get(), data.Size());
 309     }
 310     ReleaseStgMedium(&content);
 311   }
 312
 313   STGMEDIUM description;
 314   if (GetData(data_object,
 315               Clipboard::GetFileDescriptorFormatType(),
 316               &description)) {
 317     {
 318       base::win::ScopedHGlobal<FILEGROUPDESCRIPTOR*> fgd(description.hGlobal);
 319       // We expect there to be at least one file in here.
 320       DCHECK_GE(fgd->cItems, 1u);
 321       filename->assign(fgd->fgd[0].cFileName);
 322     }
 323     ReleaseStgMedium(&description);
 324   }
 325   return true;
 326 }
 327
 328 bool ClipboardUtil::GetWebCustomData(
 329     IDataObject* data_object,
 330     std::map<base::string16, base::string16>* custom_data) {
 331   DCHECK(data_object && custom_data);
 332
 333   if (!HasData(data_object, Clipboard::GetWebCustomDataFormatType()))
 334     return false;
 335
 336   STGMEDIUM store;
 337   if (GetData(data_object, Clipboard::GetWebCustomDataFormatType(), &store)) {
 338     {
 339       base::win::ScopedHGlobal<char*> data(store.hGlobal);
 340       ReadCustomDataIntoMap(data.get(), data.Size(), custom_data);
 341     }
 342     ReleaseStgMedium(&store);
 343     return true;
 344   }
 345   return false;
 346 }
 347
 348
 349 // HtmlToCFHtml and CFHtmlToHtml are based on similar methods in
 350 // WebCore/platform/win/ClipboardUtilitiesWin.cpp.
 351 /*
 352  * Copyright (C) 2007, 2008 Apple Inc. All rights reserved.
 353  *
 354  * Redistribution and use in source and binary forms, with or without
 355  * modification, are permitted provided that the following conditions
 356  * are met:
 357  * 1. Redistributions of source code must retain the above copyright
 358  *    notice, this list of conditions and the following disclaimer.
 359  * 2. Redistributions in binary form must reproduce the above copyright
 360  *    notice, this list of conditions and the following disclaimer in the
 361  *    documentation and/or other materials provided with the distribution.
 362  *
 363  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 364  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 365  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 366  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 367  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 368  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 369  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 370  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 371  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 372  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 373  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 374  */
 375
 376 // Helper method for converting from text/html to MS CF_HTML.
 377 // Documentation for the CF_HTML format is available at
 378 // http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx
 379 std::string ClipboardUtil::HtmlToCFHtml(const std::string& html,
 380                                         const std::string& base_url) {
 381   if (html.empty())
 382     return std::string();
 383
 384   #define MAX_DIGITS 10
 385   #define MAKE_NUMBER_FORMAT_1(digits) MAKE_NUMBER_FORMAT_2(digits)
 386   #define MAKE_NUMBER_FORMAT_2(digits) "%0" #digits "u"
 387   #define NUMBER_FORMAT MAKE_NUMBER_FORMAT_1(MAX_DIGITS)
 388
 389   static const char* header = "Version:0.9\r\n"
 390       "StartHTML:" NUMBER_FORMAT "\r\n"
 391       "EndHTML:" NUMBER_FORMAT "\r\n"
 392       "StartFragment:" NUMBER_FORMAT "\r\n"
 393       "EndFragment:" NUMBER_FORMAT "\r\n";
 394   static const char* source_url_prefix = "SourceURL:";
 395
 396   static const char* start_markup =
 397       "<html>\r\n<body>\r\n<!--StartFragment-->";
 398   static const char* end_markup =
 399       "<!--EndFragment-->\r\n</body>\r\n</html>";
 400
 401   // Calculate offsets
 402   size_t start_html_offset = strlen(header) - strlen(NUMBER_FORMAT) * 4 +
 403       MAX_DIGITS * 4;
 404   if (!base_url.empty()) {
 405     start_html_offset += strlen(source_url_prefix) +
 406         base_url.length() + 2;  // Add 2 for \r\n.
 407   }
 408   size_t start_fragment_offset = start_html_offset + strlen(start_markup);
 409   size_t end_fragment_offset = start_fragment_offset + html.length();
 410   size_t end_html_offset = end_fragment_offset + strlen(end_markup);
 411
 412   std::string result = base::StringPrintf(header,
 413                                           start_html_offset,
 414                                           end_html_offset,
 415                                           start_fragment_offset,
 416                                           end_fragment_offset);
 417   if (!base_url.empty()) {
 418     result.append(source_url_prefix);
 419     result.append(base_url);
 420     result.append("\r\n");
 421   }
 422   result.append(start_markup);
 423   result.append(html);
 424   result.append(end_markup);
 425
 426   #undef MAX_DIGITS
 427   #undef MAKE_NUMBER_FORMAT_1
 428   #undef MAKE_NUMBER_FORMAT_2
 429   #undef NUMBER_FORMAT
 430
 431   return result;
 432 }
 433
 434 // Helper method for converting from MS CF_HTML to text/html.
 435 void ClipboardUtil::CFHtmlToHtml(const std::string& cf_html,
 436                                  std::string* html,
 437                                  std::string* base_url) {
 438   size_t fragment_start = std::string::npos;
 439   size_t fragment_end = std::string::npos;
 440
 441   ClipboardUtil::CFHtmlExtractMetadata(
 442       cf_html, base_url, NULL, &fragment_start, &fragment_end);
 443
 444   if (html &&
 445       fragment_start != std::string::npos &&
 446       fragment_end != std::string::npos) {
 447     *html = cf_html.substr(fragment_start, fragment_end - fragment_start);
 448     base::TrimWhitespace(*html, base::TRIM_ALL, html);
 449   }
 450 }
 451
 452 void ClipboardUtil::CFHtmlExtractMetadata(const std::string& cf_html,
 453                                           std::string* base_url,
 454                                           size_t* html_start,
 455                                           size_t* fragment_start,
 456                                           size_t* fragment_end) {
 457   // Obtain base_url if present.
 458   if (base_url) {
 459     static std::string src_url_str("SourceURL:");
 460     size_t line_start = cf_html.find(src_url_str);
 461     if (line_start != std::string::npos) {
 462       size_t src_end = cf_html.find("\n", line_start);
 463       size_t src_start = line_start + src_url_str.length();
 464       if (src_end != std::string::npos && src_start != std::string::npos) {
 465         *base_url = cf_html.substr(src_start, src_end - src_start);
 466         base::TrimWhitespace(*base_url, base::TRIM_ALL, base_url);
 467       }
 468     }
 469   }
 470
 471   // Find the markup between "<!--StartFragment-->" and "<!--EndFragment-->".
 472   // If the comments cannot be found, like copying from OpenOffice Writer,
 473   // we simply fall back to using StartFragment/EndFragment bytecount values
 474   // to determine the fragment indexes.
 475   std::string cf_html_lower = StringToLowerASCII(cf_html);
 476   size_t markup_start = cf_html_lower.find("<html", 0);
 477   if (html_start) {
 478     *html_start = markup_start;
 479   }
 480   size_t tag_start = cf_html.find("<!--StartFragment", markup_start);
 481   if (tag_start == std::string::npos) {
 482     static std::string start_fragment_str("StartFragment:");
 483     size_t start_fragment_start = cf_html.find(start_fragment_str);
 484     if (start_fragment_start != std::string::npos) {
 485       *fragment_start = static_cast<size_t>(atoi(cf_html.c_str() +
 486           start_fragment_start + start_fragment_str.length()));
 487     }
 488
 489     static std::string end_fragment_str("EndFragment:");
 490     size_t end_fragment_start = cf_html.find(end_fragment_str);
 491     if (end_fragment_start != std::string::npos) {
 492       *fragment_end = static_cast<size_t>(atoi(cf_html.c_str() +
 493           end_fragment_start + end_fragment_str.length()));
 494     }
 495   } else {
 496     *fragment_start = cf_html.find('>', tag_start) + 1;
 497     size_t tag_end = cf_html.rfind("<!--EndFragment", std::string::npos);
 498     *fragment_end = cf_html.rfind('<', tag_end);
 499   }
 500 }
 501
 502 }  // namespace ui