chromeos: Add SurfaceServiceProvider.

chromeos/dbus/services/surface_service_provider.cc

+// 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 {
+
+void OnGraphicsBufferCreated(
+    const dbus::ExportedObject::ResponseSender& response_sender,
+    scoped_ptr<dbus::Response> response,
+    int32 buffer) {
+  dbus::MessageWriter writer(response.get());
+  writer.AppendInt32(buffer);
+  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->ExportMethod(
+      kLibCrosServiceInterface, kCreateGraphicsBufferFromUnixFd,
+      base::Bind(&SurfaceServiceProvider::CreateGraphicsBufferFromUnixFd,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object->ExportMethod(
+      kLibCrosServiceInterface, kDestroyGraphicsBuffer,
+      base::Bind(&SurfaceServiceProvider::DestroyGraphicsBuffer,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+
+  exported_object->ExportMethod(
+      kLibCrosServiceInterface, kSetTestSurfaceContents,
+      base::Bind(&SurfaceServiceProvider::SetTestSurfaceContents,
+                 weak_ptr_factory_.GetWeakPtr()),
+      base::Bind(&SurfaceServiceProvider::OnExported,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
+void SurfaceServiceProvider::CreateGraphicsBufferFromUnixFd(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  uint32 width = 0;
+  uint32 height = 0;
+  dbus::FileDescriptor fd;
+  uint32 stride = 0;
+  dbus::MessageReader reader(method_call);
+  if (!reader.PopUint32(&width) || !reader.PopUint32(&height) ||
+      !reader.PopFileDescriptor(&fd) || !reader.PopUint32(&stride)) {
+    LOG(ERROR) << "Unable to parse " << kCreateGraphicsBufferFromUnixFd
+               << " request";
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
+    return;
+  }
+
+  fd.CheckValidity();
+  if (!fd.is_valid()) {
+    LOG(ERROR) << kCreateGraphicsBufferFromUnixFd
+               << " request contained an invalid file descriptor";
+    response_sender.Run(dbus::Response::FromMethodCall(method_call));
+    return;
+  }
+
+  delegate_->CreateGraphicsBufferFromUnixFd(
+      gfx::Size(width, height), base::ScopedFD(fd.TakeValue()), stride,
+      base::Bind(&OnGraphicsBufferCreated, response_sender,
+                 base::Passed(dbus::Response::FromMethodCall(method_call))));
+}
+
+void SurfaceServiceProvider::DestroyGraphicsBuffer(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  int32 buffer = 0;
+  dbus::MessageReader reader(method_call);
+  if (reader.PopInt32(&buffer)) {
+    delegate_->DestroyGraphicsBuffer(buffer);
+  } else {
+    LOG(ERROR) << "Unable to parse " << kDestroyGraphicsBuffer << " request";
+  }
+  response_sender.Run(dbus::Response::FromMethodCall(method_call));
+}
+
+void SurfaceServiceProvider::SetTestSurfaceContents(
+    dbus::MethodCall* method_call,
+    dbus::ExportedObject::ResponseSender response_sender) {
+  int32 buffer = 0;
+  dbus::MessageReader reader(method_call);
+  if (reader.PopInt32(&buffer)) {
+    delegate_->SetTestSurfaceContents(buffer);
+  } else {
+    LOG(ERROR) << "Unable to parse " << kSetTestSurfaceContents << " request";
+  }
+  response_sender.Run(dbus::Response::FromMethodCall(method_call));
+}
+
+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