summaryrefslogtreecommitdiffstats
path: root/components/clipboard
diff options
context:
space:
mode:
authorsky <sky@chromium.org>2015-04-20 16:44:51 -0700
committerCommit bot <commit-bot@chromium.org>2015-04-20 23:45:39 +0000
commit8327ac08ec2c80f26c73a83b75a66eae7b27e3cc (patch)
treea68b6bbfba04c1fa98f081533a7100847d834d0d /components/clipboard
parent638ab71c6b28552e6adb7fd195ce50195b24725a (diff)
downloadchromium_src-8327ac08ec2c80f26c73a83b75a66eae7b27e3cc.zip
chromium_src-8327ac08ec2c80f26c73a83b75a66eae7b27e3cc.tar.gz
chromium_src-8327ac08ec2c80f26c73a83b75a66eae7b27e3cc.tar.bz2
Moves mojo/services/* to components/* part 1
I'm splitting this up in chunks so I can actually use the cq. R=ben@chromium.org Review URL: https://codereview.chromium.org/1097183002 Cr-Commit-Position: refs/heads/master@{#325942}
Diffstat (limited to 'components/clipboard')
-rw-r--r--components/clipboard/BUILD.gn44
-rw-r--r--components/clipboard/DEPS6
-rw-r--r--components/clipboard/clipboard_apptest.cc156
-rw-r--r--components/clipboard/clipboard_standalone_impl.cc89
-rw-r--r--components/clipboard/clipboard_standalone_impl.h62
-rw-r--r--components/clipboard/main.cc37
6 files changed, 394 insertions, 0 deletions
diff --git a/components/clipboard/BUILD.gn b/components/clipboard/BUILD.gn
new file mode 100644
index 0000000..cfdcb25
--- /dev/null
+++ b/components/clipboard/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright 2014 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.
+
+import("//third_party/mojo/src/mojo/public/mojo_application.gni")
+
+mojo_native_application("clipboard") {
+ sources = [
+ "clipboard_standalone_impl.cc",
+ "clipboard_standalone_impl.h",
+ "main.cc",
+ ]
+
+ deps = [
+ "//base",
+ "//mojo/application",
+ "//mojo/common",
+ "//mojo/environment:chromium",
+ "//third_party/mojo/src/mojo/public/cpp/bindings",
+ "//third_party/mojo/src/mojo/public/cpp/bindings:callback",
+ "//third_party/mojo_services/src/clipboard/public/interfaces",
+ ]
+}
+
+mojo_native_application("apptests") {
+ output_name = "clipboard_apptests"
+
+ testonly = true
+
+ sources = [
+ "clipboard_apptest.cc",
+ ]
+
+ deps = [
+ "//base",
+ "//mojo/application",
+ "//mojo/application:test_support",
+ "//mojo/common",
+ "//third_party/mojo/src/mojo/public/cpp/bindings",
+ "//third_party/mojo_services/src/clipboard/public/interfaces",
+ ]
+
+ data_deps = [ ":clipboard($default_toolchain)" ]
+}
diff --git a/components/clipboard/DEPS b/components/clipboard/DEPS
new file mode 100644
index 0000000..6e68eac
--- /dev/null
+++ b/components/clipboard/DEPS
@@ -0,0 +1,6 @@
+include_rules = [
+ "+mojo/application",
+ "+mojo/common",
+ "+third_party/mojo_services/src/clipboard",
+ "+third_party/mojo/src/mojo/public",
+]
diff --git a/components/clipboard/clipboard_apptest.cc b/components/clipboard/clipboard_apptest.cc
new file mode 100644
index 0000000..bda9469
--- /dev/null
+++ b/components/clipboard/clipboard_apptest.cc
@@ -0,0 +1,156 @@
+// Copyright 2014 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 "base/bind.h"
+#include "base/run_loop.h"
+#include "mojo/application/application_test_base_chromium.h"
+#include "mojo/common/common_type_converters.h"
+#include "third_party/mojo/src/mojo/public/cpp/application/application_impl.h"
+#include "third_party/mojo_services/src/clipboard/public/interfaces/clipboard.mojom.h"
+
+using mojo::Array;
+using mojo::Clipboard;
+using mojo::Map;
+using mojo::String;
+
+namespace {
+
+void CopyUint64AndEndRunloop(uint64_t* output,
+ base::RunLoop* run_loop,
+ uint64_t input) {
+ *output = input;
+ run_loop->Quit();
+}
+
+void CopyStringAndEndRunloop(std::string* output,
+ bool* string_is_null,
+ base::RunLoop* run_loop,
+ const Array<uint8_t>& input) {
+ *string_is_null = input.is_null();
+ *output = input.is_null() ? "" : input.To<std::string>();
+ run_loop->Quit();
+}
+
+void CopyVectorStringAndEndRunloop(std::vector<std::string>* output,
+ base::RunLoop* run_loop,
+ const Array<String>& input) {
+ *output = input.To<std::vector<std::string> >();
+ run_loop->Quit();
+}
+
+const char* kUninitialized = "Uninitialized data";
+const char* kPlainTextData = "Some plain data";
+const char* kHtmlData = "<html>data</html>";
+
+} // namespace
+
+namespace clipboard {
+
+class ClipboardAppTest : public mojo::test::ApplicationTestBase {
+ public:
+ ClipboardAppTest() : ApplicationTestBase() {}
+ ~ClipboardAppTest() override {}
+
+ void SetUp() override {
+ mojo::test::ApplicationTestBase::SetUp();
+ application_impl()->ConnectToService("mojo:clipboard", &clipboard_);
+ }
+
+ uint64_t GetSequenceNumber() {
+ base::RunLoop run_loop;
+ uint64_t sequence_num = 999999;
+ clipboard_->GetSequenceNumber(
+ Clipboard::TYPE_COPY_PASTE,
+ base::Bind(&CopyUint64AndEndRunloop, &sequence_num, &run_loop));
+ run_loop.Run();
+ return sequence_num;
+ }
+
+ std::vector<std::string> GetAvailableFormatMimeTypes() {
+ base::RunLoop run_loop;
+ std::vector<std::string> types;
+ types.push_back(kUninitialized);
+ clipboard_->GetAvailableMimeTypes(
+ Clipboard::TYPE_COPY_PASTE,
+ base::Bind(&CopyVectorStringAndEndRunloop, &types, &run_loop));
+ run_loop.Run();
+ return types;
+ }
+
+ bool GetDataOfType(const std::string& mime_type, std::string* data) {
+ base::RunLoop run_loop;
+ bool is_null = false;
+ clipboard_->ReadMimeType(
+ Clipboard::TYPE_COPY_PASTE, mime_type,
+ base::Bind(&CopyStringAndEndRunloop, data, &is_null, &run_loop));
+ run_loop.Run();
+ return !is_null;
+ }
+
+ void SetStringText(const std::string& data) {
+ Map<String, Array<uint8_t>> mime_data;
+ mime_data[Clipboard::MIME_TYPE_TEXT] = Array<uint8_t>::From(data);
+ clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE,
+ mime_data.Pass());
+ }
+
+ protected:
+ mojo::ClipboardPtr clipboard_;
+
+ DISALLOW_COPY_AND_ASSIGN(ClipboardAppTest);
+};
+
+TEST_F(ClipboardAppTest, EmptyClipboardOK) {
+ EXPECT_EQ(0ul, GetSequenceNumber());
+ EXPECT_TRUE(GetAvailableFormatMimeTypes().empty());
+ std::string data;
+ EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
+}
+
+TEST_F(ClipboardAppTest, CanReadBackText) {
+ std::string data;
+ EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
+ EXPECT_EQ(0ul, GetSequenceNumber());
+
+ SetStringText(kPlainTextData);
+ EXPECT_EQ(1ul, GetSequenceNumber());
+
+ 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[Clipboard::MIME_TYPE_TEXT] =
+ Array<uint8_t>::From(std::string(kPlainTextData));
+ mime_data[Clipboard::MIME_TYPE_HTML] =
+ Array<uint8_t>::From(std::string(kHtmlData));
+
+ clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE, mime_data.Pass());
+
+ EXPECT_EQ(1ul, GetSequenceNumber());
+
+ std::string data;
+ EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
+ EXPECT_EQ(kPlainTextData, data);
+ EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_HTML, &data));
+ EXPECT_EQ(kHtmlData, data);
+}
+
+TEST_F(ClipboardAppTest, CanClearClipboardWithZeroArray) {
+ std::string data;
+ SetStringText(kPlainTextData);
+ EXPECT_EQ(1ul, GetSequenceNumber());
+
+ EXPECT_TRUE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
+ EXPECT_EQ(kPlainTextData, data);
+
+ Map<String, Array<uint8_t>> mime_data;
+ clipboard_->WriteClipboardData(Clipboard::TYPE_COPY_PASTE, mime_data.Pass());
+
+ EXPECT_EQ(2ul, GetSequenceNumber());
+ EXPECT_FALSE(GetDataOfType(Clipboard::MIME_TYPE_TEXT, &data));
+}
+
+} // namespace clipboard
diff --git a/components/clipboard/clipboard_standalone_impl.cc b/components/clipboard/clipboard_standalone_impl.cc
new file mode 100644
index 0000000..2cf03c2
--- /dev/null
+++ b/components/clipboard/clipboard_standalone_impl.cc
@@ -0,0 +1,89 @@
+// Copyright 2014 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 "components/clipboard/clipboard_standalone_impl.h"
+
+#include <string.h>
+
+#include "third_party/mojo/src/mojo/public/cpp/bindings/array.h"
+#include "third_party/mojo/src/mojo/public/cpp/bindings/callback.h"
+#include "third_party/mojo/src/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.
+class ClipboardStandaloneImpl::ClipboardData {
+ public:
+ ClipboardData() {}
+ ~ClipboardData() {}
+
+ Array<String> GetMimeTypes() const {
+ Array<String> types(data_types_.size());
+ int i = 0;
+ for (auto it = data_types_.begin(); it != data_types_.end(); ++it, ++i)
+ types[i] = it.GetKey();
+
+ return types.Pass();
+ }
+
+ void SetData(Map<String, Array<uint8_t>> data) { data_types_ = data.Pass(); }
+
+ 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();
+ }
+
+ private:
+ Map<String, Array<uint8_t>> data_types_;
+
+ DISALLOW_COPY_AND_ASSIGN(ClipboardData);
+};
+
+ClipboardStandaloneImpl::ClipboardStandaloneImpl(
+ mojo::InterfaceRequest<mojo::Clipboard> request)
+ : binding_(this, request.Pass()) {
+ for (int i = 0; i < kNumClipboards; ++i) {
+ sequence_number_[i] = 0;
+ clipboard_state_[i].reset(new ClipboardData);
+ }
+}
+
+ClipboardStandaloneImpl::~ClipboardStandaloneImpl() {
+}
+
+void ClipboardStandaloneImpl::GetSequenceNumber(
+ Clipboard::Type clipboard_type,
+ const mojo::Callback<void(uint64_t)>& callback) {
+ callback.Run(sequence_number_[clipboard_type]);
+}
+
+void ClipboardStandaloneImpl::GetAvailableMimeTypes(
+ Clipboard::Type clipboard_type,
+ const mojo::Callback<void(Array<String>)>& callback) {
+ callback.Run(clipboard_state_[clipboard_type]->GetMimeTypes().Pass());
+}
+
+void ClipboardStandaloneImpl::ReadMimeType(
+ Clipboard::Type clipboard_type,
+ 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,
+ Map<String, Array<uint8_t>> data) {
+ sequence_number_[clipboard_type]++;
+ clipboard_state_[clipboard_type]->SetData(data.Pass());
+}
+
+} // namespace clipboard
diff --git a/components/clipboard/clipboard_standalone_impl.h b/components/clipboard/clipboard_standalone_impl.h
new file mode 100644
index 0000000..eecae95
--- /dev/null
+++ b/components/clipboard/clipboard_standalone_impl.h
@@ -0,0 +1,62 @@
+// Copyright 2014 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.
+
+#ifndef COMPONENTS_CLIPBOARD_CLIPBOARD_STANDALONE_IMPL_H_
+#define COMPONENTS_CLIPBOARD_CLIPBOARD_STANDALONE_IMPL_H_
+
+#include <base/memory/scoped_ptr.h>
+#include <string>
+
+#include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
+#include "third_party/mojo_services/src/clipboard/public/interfaces/clipboard.mojom.h"
+
+namespace clipboard {
+
+// Stub clipboard implementation.
+//
+// Eventually, we'll actually want to interact with the system clipboard, but
+// that's hard today because the system clipboard is asynchronous (on X11), the
+// 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 mojo::Clipboard {
+ public:
+ // mojo::Clipboard exposes three possible clipboards.
+ static const int kNumClipboards = 3;
+
+ explicit ClipboardStandaloneImpl(
+ mojo::InterfaceRequest<mojo::Clipboard> request);
+ ~ClipboardStandaloneImpl() override;
+
+ // mojo::Clipboard implementation.
+ void GetSequenceNumber(
+ mojo::Clipboard::Type clipboard_type,
+ const mojo::Callback<void(uint64_t)>& callback) override;
+ void GetAvailableMimeTypes(
+ mojo::Clipboard::Type clipboard_types,
+ const mojo::Callback<void(mojo::Array<mojo::String>)>& callback) override;
+ void ReadMimeType(
+ mojo::Clipboard::Type clipboard_type,
+ const mojo::String& mime_type,
+ const mojo::Callback<void(mojo::Array<uint8_t>)>& callback) override;
+ void WriteClipboardData(
+ mojo::Clipboard::Type clipboard_type,
+ mojo::Map<mojo::String, mojo::Array<uint8_t>> data) override;
+
+ private:
+ uint64_t sequence_number_[kNumClipboards];
+
+ // Internal struct which stores the current state of the clipboard.
+ class ClipboardData;
+
+ // The current clipboard state. This is what is read from.
+ scoped_ptr<ClipboardData> clipboard_state_[kNumClipboards];
+ mojo::StrongBinding<mojo::Clipboard> binding_;
+
+ DISALLOW_COPY_AND_ASSIGN(ClipboardStandaloneImpl);
+};
+
+} // namespace clipboard
+
+#endif // COMPONENTS_CLIPBOARD_CLIPBOARD_STANDALONE_IMPL_H_
diff --git a/components/clipboard/main.cc b/components/clipboard/main.cc
new file mode 100644
index 0000000..75667d1
--- /dev/null
+++ b/components/clipboard/main.cc
@@ -0,0 +1,37 @@
+// Copyright 2014 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 "components/clipboard/clipboard_standalone_impl.h"
+#include "mojo/application/application_runner_chromium.h"
+#include "third_party/mojo/src/mojo/public/c/system/main.h"
+#include "third_party/mojo/src/mojo/public/cpp/application/application_connection.h"
+#include "third_party/mojo/src/mojo/public/cpp/application/application_delegate.h"
+#include "third_party/mojo/src/mojo/public/cpp/application/interface_factory.h"
+
+class Delegate : public mojo::ApplicationDelegate,
+ public mojo::InterfaceFactory<mojo::Clipboard> {
+ public:
+ Delegate() {}
+ ~Delegate() override {}
+
+ // mojo::ApplicationDelegate implementation.
+ bool ConfigureIncomingConnection(
+ mojo::ApplicationConnection* connection) override {
+ connection->AddService(this);
+ return true;
+ }
+
+ // mojo::InterfaceFactory<mojo::Clipboard> implementation.
+ void Create(mojo::ApplicationConnection* connection,
+ 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.
+ new clipboard::ClipboardStandaloneImpl(request.Pass());
+ }
+};
+
+MojoResult MojoMain(MojoHandle shell_handle) {
+ mojo::ApplicationRunnerChromium runner(new Delegate);
+ return runner.Run(shell_handle);
+}
generated by cgit v1.1 at 2025-02-02 10:19:17 +0000