Move WebDropData to content::DropData and split off conversion function.

content/browser/web_contents/web_contents_drag_win.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 "content/browser/web_contents/web_contents_drag_win.h"
 
 #include <windows.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/message_loop.h"
 #include "base/pickle.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "content/browser/download/drag_download_file.h"
 #include "content/browser/download/drag_download_util.h"
 #include "content/browser/web_contents/web_drag_dest_win.h"
 #include "content/browser/web_contents/web_drag_source_win.h"
 #include "content/browser/web_contents/web_drag_utils_win.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/browser/web_drag_dest_delegate.h"
+#include "content/public/common/drop_data.h"
 #include "net/base/net_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/clipboard/custom_data_helper.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/layout.h"
 #include "ui/base/win/scoped_ole_initializer.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size.h"
-#include "webkit/common/webdropdata.h"
 
 using WebKit::WebDragOperationsMask;
 using WebKit::WebDragOperationCopy;
 using WebKit::WebDragOperationLink;
 using WebKit::WebDragOperationMove;
 
 namespace content {
 namespace {
 
 bool run_do_drag_drop = true;
@@ skipping 98 matching lines @@
       drag_dest_(drag_dest),
       drag_ended_(false),
       drag_end_callback_(drag_end_callback) {
 }
 
 WebContentsDragWin::~WebContentsDragWin() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!drag_drop_thread_.get());
 }
 
-void WebContentsDragWin::StartDragging(const WebDropData& drop_data,
+void WebContentsDragWin::StartDragging(const DropData& drop_data,
                                        WebDragOperationsMask ops,
                                        const gfx::ImageSkia& image,
                                        const gfx::Vector2d& image_offset) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drag_source_ = new WebDragSource(source_window_, web_contents_);
 
   const GURL& page_url = web_contents_->GetURL();
   const std::string& page_encoding = web_contents_->GetEncoding();
 
@@ skipping 15 matching lines @@
         FROM_HERE,
         base::Bind(&WebContentsDragWin::StartBackgroundDragging, this,
                    drop_data, ops, page_url, page_encoding,
                    image, image_offset));
   }
 
   EnableBackgroundDraggingSupport(drag_drop_thread_->thread_id());
 }
 
 void WebContentsDragWin::StartBackgroundDragging(
-    const WebDropData& drop_data,
+    const DropData& drop_data,
     WebDragOperationsMask ops,
     const GURL& page_url,
     const std::string& page_encoding,
     const gfx::ImageSkia& image,
     const gfx::Vector2d& image_offset) {
   drag_drop_thread_id_ = base::PlatformThread::CurrentId();
 
   if (DoDragging(drop_data, ops, page_url, page_encoding,
                  image, image_offset)) {
     BrowserThread::PostTask(
@@ skipping 10 matching lines @@
     // 2) Stop the background thread. This is done in OnDataObjectDisposed.
     //    Only drag_drop_thread_ member is accessed.
     BrowserThread::PostTask(
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(&DisableBackgroundDraggingSupport));
   }
 }
 
 void WebContentsDragWin::PrepareDragForDownload(
-    const WebDropData& drop_data,
+    const DropData& drop_data,
     ui::OSExchangeData* data,
     const GURL& page_url,
     const std::string& page_encoding) {
   // Parse the download metadata.
   string16 mime_type;
   base::FilePath file_name;
   GURL download_url;
   if (!ParseDownloadMetadata(drop_data.download_metadata,
                              &mime_type,
                              &file_name,
@@ skipping 34 matching lines @@
           web_contents_);
   ui::OSExchangeData::DownloadFileInfo file_download(base::FilePath(),
                                                      download_file.get());
   data->SetDownloadFileInfo(file_download);
 
   // Enable asynchronous operation.
   ui::OSExchangeDataProviderWin::GetIAsyncOperation(*data)->SetAsyncMode(TRUE);
 }
 
 void WebContentsDragWin::PrepareDragForFileContents(
-    const WebDropData& drop_data, ui::OSExchangeData* data) {
+    const DropData& drop_data, ui::OSExchangeData* data) {
   static const int kMaxFilenameLength = 255;  // FAT and NTFS
   base::FilePath file_name(drop_data.file_description_filename);
 
   // Images without ALT text will only have a file extension so we need to
   // synthesize one from the provided extension and URL.
   if (file_name.BaseName().RemoveExtension().empty()) {
     const string16 extension = file_name.Extension();
     // Retrieve the name from the URL.
     file_name = base::FilePath(
         net::GetSuggestedFilename(drop_data.url, "", "", "", "", ""));
     if (file_name.value().size() + extension.size() > kMaxFilenameLength) {
       file_name = base::FilePath(file_name.value().substr(
           0, kMaxFilenameLength - extension.size()));
     }
     file_name = file_name.ReplaceExtension(extension);
   }
   data->SetFileContents(file_name, drop_data.file_contents);
 }
 
-void WebContentsDragWin::PrepareDragForUrl(const WebDropData& drop_data,
+void WebContentsDragWin::PrepareDragForUrl(const DropData& drop_data,
                                            ui::OSExchangeData* data) {
   if (drag_dest_->delegate() &&
       drag_dest_->delegate()->AddDragData(drop_data, data)) {
     return;
   }
 
   data->SetURL(drop_data.url, drop_data.url_title);
 }
 
-bool WebContentsDragWin::DoDragging(const WebDropData& drop_data,
+bool WebContentsDragWin::DoDragging(const DropData& drop_data,
                                     WebDragOperationsMask ops,
                                     const GURL& page_url,
                                     const std::string& page_encoding,
                                     const gfx::ImageSkia& image,
                                     const gfx::Vector2d& image_offset) {
   ui::OSExchangeData data;
 
   if (!drop_data.download_metadata.empty()) {
     PrepareDragForDownload(drop_data, &data, page_url, page_encoding);
 
@@ skipping 113 matching lines @@
       FROM_HERE,
       base::Bind(&WebContentsDragWin::CloseThread, this));
 }
 
 // static
 void WebContentsDragWin::DisableDragDropForTesting() {
   run_do_drag_drop = false;
 }
 
 }  // namespace content