chromeos: Add SurfaceServiceProvider.

chromeos/dbus/services/surface_service_provider.cc

Index: chromeos/dbus/services/surface_service_provider.cc
diff --git a/chromeos/dbus/services/surface_service_provider.cc b/chromeos/dbus/services/surface_service_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..67b92dec6bd8be3237a51975aed4f9c422d77d9e
--- /dev/null
+++ b/chromeos/dbus/services/surface_service_provider.cc
@@ -0,0 +1,135 @@
+// Copyright 2015 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 "chromeos/dbus/services/surface_service_provider.h"
+
+#include "base/bind.h"
+#include "dbus/message.h"
+#include "third_party/cros_system_api/dbus/service_constants.h"
+
+namespace chromeos {
+namespace {
+
+// TODO(reveman): Move all these constants to third_party/cros_system_api.
+const char kCreatePrimeBuffer[] = "CreatePrimeBuffer";
+const char kDestroyBuffer[] = "DestroyBuffer";
+const char kReleaseBuffer[] = "ReleaseBuffer";
+const char kAttachBufferToTestShellSurface[] = "AttachBufferToTestShellSurface";
+
+void OnBufferCreated(
+    const dbus::ExportedObject::ResponseSender& response_sender,
+    scoped_ptr<dbus::Response> response,
+    bool success) {
+  // TODO(reveman): Send error response if success is false.
+  response_sender.Run(response.Pass());
+}
+
+}  // namespace
+
+SurfaceServiceProvider::SurfaceServiceProvider(scoped_ptr<Delegate> delegate)
+    : delegate_(delegate.Pass()), weak_ptr_factory_(this) {}
+
+SurfaceServiceProvider::~SurfaceServiceProvider() {}
+
+void SurfaceServiceProvider::Start(
+    scoped_refptr<dbus::ExportedObject> exported_object) {
+  exported_object_ = exported_object;
+  exported_object_->ExportMethod(
+      kLibCrosServiceInterface, kCreatePrimeBuffer,
+      base::Bind(&SurfaceServiceProvider::CreatePrimeBuffer,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object_->ExportMethod(
+      kLibCrosServiceInterface, kDestroyBuffer,
+      base::Bind(&SurfaceServiceProvider::DestroyBuffer,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object_->ExportMethod(
+      kLibCrosServiceInterface, kAttachBufferToTestShellSurface,
+      base::Bind(&SurfaceServiceProvider::AttachBufferToTestShellSurface,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void SurfaceServiceProvider::CreatePrimeBuffer(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  uint32 id = 0;
+  dbus::FileDescriptor name;
+  int32 width = 0;
+  int32 height = 0;
+  uint32 format = 0;
+  int32 stride = 0;
+  dbus::MessageReader reader(method_call);
+  if (!reader.PopUint32(&id) || !reader.PopFileDescriptor(&name) ||
+      !reader.PopInt32(&width) || !reader.PopInt32(&height) ||
+      !reader.PopUint32(&format) || !reader.PopInt32(&stride)) {
+    LOG(ERROR) << "Unable to parse " << kCreatePrimeBuffer << " request";
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
+    return;
+  }
+
+  name.CheckValidity();
+  if (!name.is_valid()) {
+    LOG(ERROR) << kCreatePrimeBuffer
+               << " request contained an invalid file descriptor";
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
+    return;
+  }
+
+  delegate_->CreatePrimeBuffer(
+      id, base::ScopedFD(name.TakeValue()), width, height, format, stride,
+      base::Bind(&OnBufferCreated, response_sender,
+                 base::Passed(dbus::Response::FromMethodCall(method_call))));
+}
+
+void SurfaceServiceProvider::DestroyBuffer(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  uint32 id = 0;
+  dbus::MessageReader reader(method_call);
+  if (reader.PopUint32(&id)) {
+    delegate_->DestroyBuffer(id);
+  } else {
+    LOG(ERROR) << "Unable to parse " << kDestroyBuffer << " request";
+  }
+  response_sender.Run(dbus::Response::FromMethodCall(method_call));
+}
+
+void SurfaceServiceProvider::AttachBufferToTestShellSurface(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  uint32 buffer_id = 0;
+  dbus::MessageReader reader(method_call);
+  if (reader.PopUint32(&buffer_id)) {
+    delegate_->AttachBufferToTestShellSurface(
+        buffer_id, base::Bind(&SurfaceServiceProvider::ReleaseBuffer,
+                              weak_ptr_factory_.GetWeakPtr(), buffer_id));
+  } else {
+    LOG(ERROR) << "Unable to parse " << kAttachBufferToTestShellSurface
+               << " request";
+  }
+  response_sender.Run(dbus::Response::FromMethodCall(method_call));
+}
+
+void SurfaceServiceProvider::ReleaseBuffer(uint32 id) {
+  dbus::Signal signal(kLibCrosServiceInterface, kReleaseBuffer);
+  dbus::MessageWriter writer(&signal);
+  writer.AppendUint32(id);
+  exported_object_->SendSignal(&signal);
+}
+
+void SurfaceServiceProvider::OnExported(const std::string& interface_name,
+                                        const std::string& method_name,
+                                        bool success) {
+  if (!success)
+    LOG(ERROR) << "failed to export " << interface_name << "." << method_name;
+}
+
+}  // namespace chromeos