Move SharedBitmapManager implementation out of content/

components/display_compositor/host_shared_bitmap_manager.cc

 // Copyright 2013 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 "content/common/host_shared_bitmap_manager.h"
+#include "components/display_compositor/host_shared_bitmap_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/stringprintf.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "build/build_config.h"
-#include "content/common/view_messages.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/gfx/geometry/size.h"
 
-namespace content {
+namespace display_compositor {
 
 class BitmapData : public base::RefCountedThreadSafe<BitmapData> {
  public:
   explicit BitmapData(size_t buffer_size) : buffer_size(buffer_size) {}
   std::unique_ptr<base::SharedMemory> memory;
   std::unique_ptr<uint8_t[]> pixels;
   size_t buffer_size;
 
  private:
   friend class base::RefCountedThreadSafe<BitmapData>;
@@ skipping 18 matching lines @@
       manager_->FreeSharedMemoryFromMap(id());
   }
 
  private:
   scoped_refptr<BitmapData> bitmap_data_;
   HostSharedBitmapManager* manager_;
 };
 
 }  // namespace
 
+class MojoSharedBitmapManagerImpl : public mojom::SharedBitmapManager {
+ public:
+  MojoSharedBitmapManagerImpl(
+      HostSharedBitmapManagerClient* bitmap_manager_client)
+      : bitmap_manager_client_(bitmap_manager_client) {}
+
+  // mojom::SharedBitmapManager overrides:
+  void AllocatedSharedBitmap(mojo::ScopedSharedBufferHandle buffer,
+                             const cc::SharedBitmapId& id) override {
+    base::SharedMemoryHandle memory_handle;
+    size_t size;
+    MojoResult result = mojo::UnwrapSharedMemoryHandle(
+        std::move(buffer), &memory_handle, &size, NULL);
+    DCHECK_EQ(result, MOJO_RESULT_OK);
+    bitmap_manager_client_->ChildAllocatedSharedBitmap(size, memory_handle, id);
+  }
+
+  void DeletedSharedBitmap(const cc::SharedBitmapId& id) override {
+    bitmap_manager_client_->ChildDeletedSharedBitmap(id);
+  }
+
+ private:
+  HostSharedBitmapManagerClient* bitmap_manager_client_;
+};
+
 base::LazyInstance<HostSharedBitmapManager> g_shared_memory_manager =
     LAZY_INSTANCE_INITIALIZER;
 
 HostSharedBitmapManagerClient::HostSharedBitmapManagerClient(
     HostSharedBitmapManager* manager)
-    : manager_(manager) {
-}
+    : manager_(manager) {}
 
 HostSharedBitmapManagerClient::~HostSharedBitmapManagerClient() {
   for (const auto& id : owned_bitmaps_)
     manager_->ChildDeletedSharedBitmap(id);
 }
 
+void HostSharedBitmapManagerClient::Bind(
+    mojom::SharedBitmapManagerRequest request) {
+  mojo::MakeStrongBinding(base::MakeUnique<MojoSharedBitmapManagerImpl>(this),
+                          std::move(request));
+}
+
 void HostSharedBitmapManagerClient::AllocateSharedBitmapForChild(
     base::ProcessHandle process_handle,
     size_t buffer_size,
     const cc::SharedBitmapId& id,
     base::SharedMemoryHandle* shared_memory_handle) {
   manager_->AllocateSharedBitmapForChild(process_handle, buffer_size, id,
                                          shared_memory_handle);
   if (*shared_memory_handle != base::SharedMemory::NULLHandle()) {
     base::AutoLock lock(lock_);
     owned_bitmaps_.insert(id);
@@ skipping 135 matching lines @@
 
   scoped_refptr<BitmapData> data(new BitmapData(buffer_size));
   data->memory = std::move(shared_memory);
 
   handle_map_[id] = data;
   if (!data->memory->ShareToProcess(process_handle, shared_memory_handle)) {
     LOG(ERROR) << "Cannot share shared memory buffer";
     *shared_memory_handle = base::SharedMemory::NULLHandle();
     return;
   }
- data->memory->Close();
+  data->memory->Close();
 }
 
 void HostSharedBitmapManager::ChildDeletedSharedBitmap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
 size_t HostSharedBitmapManager::AllocatedBitmapCount() const {
   base::AutoLock lock(lock_);
   return handle_map_.size();
 }
 
 void HostSharedBitmapManager::FreeSharedMemoryFromMap(
     const cc::SharedBitmapId& id) {
   base::AutoLock lock(lock_);
   handle_map_.erase(id);
 }
 
-}  // namespace content
+}  // namespace display_compositor