Moves OSExchangeDataProviderMus to aura/mus

ui/aura/mus/os_exchange_data_provider_mus.cc

 // Copyright 2016 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 "ui/views/mus/os_exchange_data_provider_mus.h"
+#include "ui/aura/mus/os_exchange_data_provider_mus.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mojo/common/common_type_converters.h"
 #include "net/base/filename_util.h"
 #include "services/ui/public/interfaces/clipboard.mojom.h"
 #include "ui/base/dragdrop/file_info.h"
 #include "url/gurl.h"
 
-namespace views {
+namespace aura {
 
 namespace {
 
 std::vector<uint8_t> FromString(const std::string& str) {
   return std::vector<uint8_t>(str.begin(), str.end());
 }
 
 std::string ToString(const std::vector<uint8_t>& v) {
   return std::string(v.begin(), v.end());
 }
 
 base::string16 ToString16(const std::vector<uint8_t>& v) {
   DCHECK_EQ(0u, v.size() % 2);
-  return base::string16(
-      reinterpret_cast<const base::char16*>(v.data()),
-      v.size() / 2);
+  return base::string16(reinterpret_cast<const base::char16*>(v.data()),
+                        v.size() / 2);
 }
 
 std::vector<base::StringPiece> ParseURIList(const std::vector<uint8_t>& data) {
   return base::SplitStringPiece(
-      base::StringPiece(
-          reinterpret_cast<const char*>(&data.front()), data.size()),
-      "\n",
-      base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+      base::StringPiece(reinterpret_cast<const char*>(&data.front()),
+                        data.size()),
+      "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
 }
 
 void AddString16ToVector(const base::string16& str,
                          std::vector<uint8_t>* bytes) {
-  const unsigned char* front =
-      reinterpret_cast<const uint8_t*>(str.data());
+  const unsigned char* front = reinterpret_cast<const uint8_t*>(str.data());
   bytes->insert(bytes->end(), front, front + (str.size() * 2));
 }
 
 }  // namespace
 
 OSExchangeDataProviderMus::OSExchangeDataProviderMus() {}
 
 OSExchangeDataProviderMus::OSExchangeDataProviderMus(Data data)
     : mime_data_(std::move(data)) {}
 
 OSExchangeDataProviderMus::~OSExchangeDataProviderMus() {}
 
 OSExchangeDataProviderMus::Data OSExchangeDataProviderMus::GetData() const {
   return mime_data_;
 }
 
-std::unique_ptr<ui::OSExchangeData::Provider>
-OSExchangeDataProviderMus::Clone() const {
+std::unique_ptr<ui::OSExchangeData::Provider> OSExchangeDataProviderMus::Clone()
+    const {
   std::unique_ptr<OSExchangeDataProviderMus> r =
       base::MakeUnique<OSExchangeDataProviderMus>();
   r->drag_image_ = drag_image_;
   r->drag_image_offset_ = drag_image_offset_;
   r->mime_data_ = mime_data_;
   return base::WrapUnique<ui::OSExchangeData::Provider>(r.release());
 }
 
 void OSExchangeDataProviderMus::MarkOriginatedFromRenderer() {
   // Currently unimplemented because ChromeOS doesn't need this.
@@ skipping 28 matching lines @@
 void OSExchangeDataProviderMus::SetFilename(const base::FilePath& path) {
   std::vector<ui::FileInfo> data;
   data.push_back(ui::FileInfo(path, base::FilePath()));
   SetFilenames(data);
 }
 
 void OSExchangeDataProviderMus::SetFilenames(
     const std::vector<ui::FileInfo>& file_names) {
   std::vector<std::string> paths;
   for (std::vector<ui::FileInfo>::const_iterator it = file_names.begin();
-       it != file_names.end();
-       ++it) {
+       it != file_names.end(); ++it) {
     std::string url_spec = net::FilePathToFileURL(it->path).spec();
     if (!url_spec.empty())
       paths.push_back(url_spec);
   }
 
   std::string joined_data = base::JoinString(paths, "\n");
   mime_data_[ui::mojom::kMimeTypeURIList] = FromString(joined_data);
 }
 
 void OSExchangeDataProviderMus::SetPickledData(
     const ui::Clipboard::FormatType& format,
     const base::Pickle& pickle) {
   const unsigned char* bytes =
       reinterpret_cast<const unsigned char*>(pickle.data());
 
-  mime_data_[format.Serialize()] = mojo::Array<uint8_t>(
-      std::vector<uint8_t>(bytes, bytes + pickle.size()));
+  mime_data_[format.Serialize()] =
+      mojo::Array<uint8_t>(std::vector<uint8_t>(bytes, bytes + pickle.size()));
 }
 
 bool OSExchangeDataProviderMus::GetString(base::string16* data) const {
   auto it = mime_data_.find(ui::mojom::kMimeTypeText);
   if (it != mime_data_.end())
     *data = base::UTF8ToUTF16(ToString(it->second));
   return it != mime_data_.end();
 }
 
 bool OSExchangeDataProviderMus::GetURLAndTitle(
@@ skipping 103 matching lines @@
 bool OSExchangeDataProviderMus::HasCustomFormat(
     const ui::Clipboard::FormatType& format) const {
   return base::ContainsKey(mime_data_, format.Serialize());
 }
 
 // These methods were added in an ad-hoc way to different operating
 // systems. We need to support them until they get cleaned up.
 #if (!defined(OS_CHROMEOS) && defined(USE_X11)) || defined(OS_WIN)
 void OSExchangeDataProviderMus::SetFileContents(
     const base::FilePath& filename,
-    const std::string& file_contents) {
-}
+    const std::string& file_contents) {}
 #endif
 
 #if defined(OS_WIN)
 bool OSExchangeDataProviderMus::GetFileContents(
     base::FilePath* filename,
     std::string* file_contents) const {
   return false;
 }
 
 bool OSExchangeDataProviderMus::HasFileContents() const {
   return false;
 }
 
 void OSExchangeDataProviderMus::SetDownloadFileInfo(
-    const ui::OSExchangeData::DownloadFileInfo& download) {
-}
+    const ui::OSExchangeData::DownloadFileInfo& download) {}
 #endif
 
 #if defined(USE_AURA)
 void OSExchangeDataProviderMus::SetHtml(const base::string16& html,
                                         const GURL& base_url) {
   std::vector<unsigned char> bytes;
   // Manually jam a UTF16 BOM into bytes because otherwise, other programs will
   // assume UTF-8.
   bytes.push_back(0xFF);
   bytes.push_back(0xFE);
   AddString16ToVector(html, &bytes);
   mime_data_[ui::mojom::kMimeTypeHTML] = bytes;
 }
 
 bool OSExchangeDataProviderMus::GetHtml(base::string16* html,
                                         GURL* base_url) const {
   auto it = mime_data_.find(ui::mojom::kMimeTypeHTML);
   if (it == mime_data_.end())
     return false;
 
   const unsigned char* data = it->second.data();
   size_t size = it->second.size();
   base::string16 markup;
 
   // If the data starts with 0xFEFF, i.e., Byte Order Mark, assume it is
   // UTF-16, otherwise assume UTF-8.
-  if (size >= 2 &&
-      reinterpret_cast<const uint16_t*>(data)[0] == 0xFEFF) {
+  if (size >= 2 && reinterpret_cast<const uint16_t*>(data)[0] == 0xFEFF) {
     markup.assign(reinterpret_cast<const base::char16*>(data) + 1,
                   (size / 2) - 1);
   } else {
     base::UTF8ToUTF16(reinterpret_cast<const char*>(data), size, &markup);
   }
 
   // If there is a terminating NULL, drop it.
   if (!markup.empty() && markup.at(markup.length() - 1) == '\0')
     markup.resize(markup.length() - 1);
 
@@ skipping 45 matching lines @@
 
   GURL test_url(str);
   if (!test_url.is_valid())
     return false;
 
   if (url)
     *url = test_url;
   return true;
 }
 
-}  // namespace views
+}  // namespace aura