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/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 23 matching lines @@
   HostSharedBitmapManager* manager_;
 };
 
 }  // namespace
 
 base::LazyInstance<HostSharedBitmapManager>::DestructorAtExit
     g_shared_memory_manager = LAZY_INSTANCE_INITIALIZER;
 
 HostSharedBitmapManagerClient::HostSharedBitmapManagerClient(
     HostSharedBitmapManager* manager)
-    : manager_(manager) {
-}
+    : manager_(manager), binding_(this) {}
 
 HostSharedBitmapManagerClient::~HostSharedBitmapManagerClient() {
   for (const auto& id : owned_bitmaps_)
     manager_->ChildDeletedSharedBitmap(id);
 }
 
+void HostSharedBitmapManagerClient::Bind(
+    cc::mojom::SharedBitmapManagerAssociatedRequest request) {
+  binding_.Bind(std::move(request));
+}
+
+void HostSharedBitmapManagerClient::DidAllocateSharedBitmap(
+    mojo::ScopedSharedBufferHandle buffer,
+    const cc::SharedBitmapId& id) {
+  base::SharedMemoryHandle memory_handle;
+  size_t size;
+  MojoResult result = mojo::UnwrapSharedMemoryHandle(
+      std::move(buffer), &memory_handle, &size, NULL);
+  DCHECK_EQ(result, MOJO_RESULT_OK);
+  this->ChildAllocatedSharedBitmap(size, memory_handle, id);
+}
+
 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);
   }
 }
 
 void HostSharedBitmapManagerClient::ChildAllocatedSharedBitmap(
     size_t buffer_size,
     const base::SharedMemoryHandle& handle,
     const cc::SharedBitmapId& id) {
   if (manager_->ChildAllocatedSharedBitmap(buffer_size, handle, id)) {
     base::AutoLock lock(lock_);
     owned_bitmaps_.insert(id);
   }
 }
 
-void HostSharedBitmapManagerClient::ChildDeletedSharedBitmap(
+void HostSharedBitmapManagerClient::DidDeleteSharedBitmap(
     const cc::SharedBitmapId& id) {
   manager_->ChildDeletedSharedBitmap(id);
   {
     base::AutoLock lock(lock_);
     owned_bitmaps_.erase(id);
   }
 }
 
 HostSharedBitmapManager::HostSharedBitmapManager() {}
 HostSharedBitmapManager::~HostSharedBitmapManager() {
@@ skipping 111 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