Move //services/clipboard code out of namespace mojo

Now that the code doesn't live under //mojo/services/ it doesn't make
sense for the types to exist in namespace mojo.

R=erg@chromium.org

Review URL: https://codereview.chromium.org/779063003
diff --git a/services/clipboard/BUILD.gn b/services/clipboard/BUILD.gn
index bcd6475..6f5d5ec 100644
--- a/services/clipboard/BUILD.gn
+++ b/services/clipboard/BUILD.gn
@@ -17,6 +17,7 @@
     "//mojo/common",
     "//mojo/environment:chromium",
     "//mojo/public/cpp/bindings",
+    "//mojo/public/cpp/bindings:callback",
     "//mojo/services/public/interfaces/clipboard",
     "//ui/base",
   ]
diff --git a/services/clipboard/clipboard_apptest.cc b/services/clipboard/clipboard_apptest.cc
index 2e78888..d736121 100644
--- a/services/clipboard/clipboard_apptest.cc
+++ b/services/clipboard/clipboard_apptest.cc
@@ -9,6 +9,11 @@
 #include "mojo/public/cpp/application/application_test_base.h"
 #include "mojo/services/public/interfaces/clipboard/clipboard.mojom.h"
 
+using mojo::Array;
+using mojo::Clipboard;
+using mojo::Map;
+using mojo::String;
+
 namespace {
 
 void CopyUint64AndEndRunloop(uint64_t* output,
@@ -21,7 +26,7 @@
 void CopyStringAndEndRunloop(std::string* output,
                              bool* string_is_null,
                              base::RunLoop* run_loop,
-                             const mojo::Array<uint8_t>& input) {
+                             const Array<uint8_t>& input) {
   *string_is_null = input.is_null();
   *output = input.is_null() ? "" : input.To<std::string>();
   run_loop->Quit();
@@ -29,7 +34,7 @@
 
 void CopyVectorStringAndEndRunloop(std::vector<std::string>* output,
                                    base::RunLoop* run_loop,
-                                   const mojo::Array<mojo::String>& input) {
+                                   const Array<String>& input) {
   *output = input.To<std::vector<std::string> >();
   run_loop->Quit();
 }
@@ -40,16 +45,15 @@
 
 }  // namespace
 
-namespace mojo {
-namespace service {
+namespace clipboard {
 
-class ClipboardAppTest : public test::ApplicationTestBase {
+class ClipboardAppTest : public mojo::test::ApplicationTestBase {
  public:
   ClipboardAppTest() : ApplicationTestBase() {}
   ~ClipboardAppTest() override {}
 
   void SetUp() override {
-    ApplicationTestBase::SetUp();
+    mojo::test::ApplicationTestBase::SetUp();
     application_impl()->ConnectToService("mojo:clipboard", &clipboard_);
   }
 
@@ -57,7 +61,7 @@
     base::RunLoop run_loop;
     uint64_t sequence_num = 999999;
     clipboard_->GetSequenceNumber(
-        mojo::Clipboard::TYPE_COPY_PASTE,
+        Clipboard::TYPE_COPY_PASTE,
         base::Bind(&CopyUint64AndEndRunloop, &sequence_num, &run_loop));
     run_loop.Run();
     return sequence_num;
@@ -68,7 +72,7 @@
     std::vector<std::string> types;
     types.push_back(kUninitialized);
     clipboard_->GetAvailableMimeTypes(
-        mojo::Clipboard::TYPE_COPY_PASTE,
+        Clipboard::TYPE_COPY_PASTE,
         base::Bind(&CopyVectorStringAndEndRunloop, &types, &run_loop));
     run_loop.Run();
     return types;
@@ -78,8 +82,7 @@
     base::RunLoop run_loop;
     bool is_null = false;
     clipboard_->ReadMimeType(
-        mojo::Clipboard::TYPE_COPY_PASTE,
-        mime_type,
+        Clipboard::TYPE_COPY_PASTE, mime_type,
         base::Bind(&CopyStringAndEndRunloop, data, &is_null, &run_loop));
     run_loop.Run();
     return !is_null;
@@ -87,13 +90,13 @@
 
   void SetStringText(const std::string& data) {
     Map<String, Array<uint8_t>> mime_data;
-    mime_data[mojo::Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data);
-    clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,
+    mime_data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data);
+    clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE,
                                    mime_data.Pass());
   }
 
  protected:
-  ClipboardPtr clipboard_;
+  mojo::ClipboardPtr clipboard_;
 
   DISALLOW_COPY_AND_ASSIGN(ClipboardAppTest);
 };
@@ -102,37 +105,36 @@
   EXPECT_EQ(0ul, GetSequenceNumber());
   EXPECT_TRUE(GetAvailableFormatMimeTypes().empty());
   std::string data;
-  EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
 }
 
 TEST_F(ClipboardAppTest, CanReadBackText) {
   std::string data;
-  EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
   EXPECT_EQ(0ul, GetSequenceNumber());
 
   SetStringText(kPlainTextData);
   EXPECT_EQ(1ul, GetSequenceNumber());
 
-  EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
   EXPECT_EQ(kPlainTextData, data);
 }
 
 TEST_F(ClipboardAppTest, CanSetMultipleDataTypesAtOnce) {
   Map<String, Array<uint8_t>> mime_data;
-  mime_data[mojo::Clipboard::MIME_TYPE_TEXT] =
+  mime_data[Clipboard::MIME_TYPE_TEXT] =
       Array<uint8_t>::From(std::string(kPlainTextData));
-  mime_data[mojo::Clipboard::MIME_TYPE_HTML] =
+  mime_data[Clipboard::MIME_TYPE_HTML] =
       Array<uint8_t>::From(std::string(kHtmlData));
 
-  clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,
-                                 mime_data.Pass());
+  clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE, mime_data.Pass());
 
   EXPECT_EQ(1ul, GetSequenceNumber());
 
   std::string data;
-  EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
   EXPECT_EQ(kPlainTextData, data);
-  EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_HTML, &data));
+  EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_HTML, &data));
   EXPECT_EQ(kHtmlData, data);
 }
 
@@ -141,16 +143,14 @@
   SetStringText(kPlainTextData);
   EXPECT_EQ(1ul, GetSequenceNumber());
 
-  EXPECT_TRUE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
   EXPECT_EQ(kPlainTextData, data);
 
   Map<String, Array<uint8_t>> mime_data;
-  clipboard_->WriteClipboardData(mojo::Clipboard::TYPE_COPY_PASTE,
-                                 mime_data.Pass());
+  clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE, mime_data.Pass());
 
   EXPECT_EQ(2ul, GetSequenceNumber());
-  EXPECT_FALSE(GetDataOfType(mojo::Clipboard::MIME_TYPE_TEXT, &data));
+  EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
 }
 
-}  // namespace service
-}  // namespace mojo
+}  // namespace clipboard
diff --git a/services/clipboard/clipboard_standalone_impl.cc b/services/clipboard/clipboard_standalone_impl.cc
index 00a2467..fb56c30 100644
--- a/services/clipboard/clipboard_standalone_impl.cc
+++ b/services/clipboard/clipboard_standalone_impl.cc
@@ -6,7 +6,15 @@
 
 #include <string.h>
 
-namespace mojo {
+#include "mojo/public/cpp/bindings/array.h"
+#include "mojo/public/cpp/bindings/callback.h"
+#include "mojo/public/cpp/bindings/string.h"
+
+using mojo::Array;
+using mojo::Map;
+using mojo::String;
+
+namespace clipboard {
 
 // ClipboardData contains data copied to the Clipboard for a variety of formats.
 // It mostly just provides APIs to cleanly access and manipulate this data.
@@ -26,7 +34,7 @@
 
   void SetData(Map<String, Array<uint8_t>> data) { data_types_ = data.Pass(); }
 
-  void GetData(const String& mime_type, mojo::Array<uint8_t>* data) const {
+  void GetData(const String& mime_type, Array<uint8_t>* data) const {
     auto it = data_types_.find(mime_type);
     if (it != data_types_.end())
       *data = it.GetValue().Clone();
@@ -56,24 +64,24 @@
 
 void ClipboardStandaloneImpl::GetAvailableMimeTypes(
     Clipboard::Type clipboard_type,
-    const mojo::Callback<void(mojo::Array<mojo::String>)>& callback) {
+    const mojo::Callback<void(Array<String>)>& callback) {
   callback.Run(clipboard_state_[clipboard_type]->GetMimeTypes().Pass());
 }
 
 void ClipboardStandaloneImpl::ReadMimeType(
     Clipboard::Type clipboard_type,
-    const mojo::String& mime_type,
-    const mojo::Callback<void(mojo::Array<uint8_t>)>& callback) {
-  mojo::Array<uint8_t> mime_data;
+    const String& mime_type,
+    const mojo::Callback<void(Array<uint8_t>)>& callback) {
+  Array<uint8_t> mime_data;
   clipboard_state_[clipboard_type]->GetData(mime_type, &mime_data);
   callback.Run(mime_data.Pass());
 }
 
 void ClipboardStandaloneImpl::WriteClipboardData(
     Clipboard::Type clipboard_type,
-    mojo::Map<mojo::String, mojo::Array<uint8_t>> data) {
+    Map<String, Array<uint8_t>> data) {
   sequence_number_[clipboard_type]++;
   clipboard_state_[clipboard_type]->SetData(data.Pass());
 }
 
-}  // namespace mojo
+}  // namespace clipboard
diff --git a/services/clipboard/clipboard_standalone_impl.h b/services/clipboard/clipboard_standalone_impl.h
index 8cffae6..fcfb9e6 100644
--- a/services/clipboard/clipboard_standalone_impl.h
+++ b/services/clipboard/clipboard_standalone_impl.h
@@ -10,7 +10,7 @@
 
 #include "mojo/services/public/interfaces/clipboard/clipboard.mojom.h"
 
-namespace mojo {
+namespace clipboard {
 
 // Stub clipboard implementation.
 //
@@ -19,7 +19,7 @@
 // ui::Clipboard interface is synchronous (which is what we'd use), mojo is
 // asynchronous across processes, and the WebClipboard interface is synchronous
 // (which is at least tractable).
-class ClipboardStandaloneImpl : public InterfaceImpl<mojo::Clipboard> {
+class ClipboardStandaloneImpl : public mojo::InterfaceImpl<mojo::Clipboard> {
  public:
   // mojo::Clipboard exposes three possible clipboards.
   static const int kNumClipboards = 3;
@@ -29,17 +29,17 @@
 
   // InterfaceImpl<mojo::Clipboard> implementation.
   void GetSequenceNumber(
-      Clipboard::Type clipboard_type,
+      mojo::Clipboard::Type clipboard_type,
       const mojo::Callback<void(uint64_t)>& callback) override;
   void GetAvailableMimeTypes(
-      Clipboard::Type clipboard_types,
+      mojo::Clipboard::Type clipboard_types,
       const mojo::Callback<void(mojo::Array<mojo::String>)>& callback) override;
   void ReadMimeType(
-      Clipboard::Type clipboard_type,
+      mojo::Clipboard::Type clipboard_type,
       const mojo::String& mime_type,
       const mojo::Callback<void(mojo::Array<uint8_t>)>& callback) override;
   void WriteClipboardData(
-      Clipboard::Type clipboard_type,
+      mojo::Clipboard::Type clipboard_type,
       mojo::Map<mojo::String, mojo::Array<uint8_t>> data) override;
 
  private:
@@ -54,6 +54,6 @@
   DISALLOW_COPY_AND_ASSIGN(ClipboardStandaloneImpl);
 };
 
-}  // namespace mojo
+}  // namespace clipboard
 
 #endif  // SERVICES_CLIPBOARD_CLIPBOARD_STANDALONE_IMPL_H_
diff --git a/services/clipboard/main.cc b/services/clipboard/main.cc
index 3072f83..f3e46fd 100644
--- a/services/clipboard/main.cc
+++ b/services/clipboard/main.cc
@@ -34,7 +34,7 @@
               mojo::InterfaceRequest<mojo::Clipboard> request) override {
     // TODO(erg): Write native implementations of the clipboard. For now, we
     // just build a clipboard which doesn't interact with the system.
-    mojo::BindToRequest(new mojo::ClipboardStandaloneImpl(), &request);
+    mojo::BindToRequest(new clipboard::ClipboardStandaloneImpl(), &request);
   }
 };