Move SharedBitmapManager implementation out of content/

content/child/blob_storage/webblobregistry_impl.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/child/blob_storage/webblobregistry_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/trace_event/trace_event.h"
+#include "components/display_compositor/child/child_shared_bitmap_manager.h"
 #include "content/child/blob_storage/blob_consolidation.h"
 #include "content/child/blob_storage/blob_transport_controller.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/fileapi/webblob_messages.h"
 #include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/WebBlobData.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebThreadSafeData.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
@@ skipping 117 matching lines @@
   if (length <= limits_.max_ipc_memory_size) {
     DataElement item;
     item.SetToBytes(data, length);
     sender_->Send(new StreamHostMsg_AppendBlobDataItem(url, item));
   } else {
     // We handle larger amounts of data via SharedMemory instead of
     // writing it directly to the IPC channel.
     size_t shared_memory_size =
         std::min(length, limits_.max_shared_memory_size);
     std::unique_ptr<base::SharedMemory> shared_memory(
-        ChildThreadImpl::AllocateSharedMemory(shared_memory_size));
+        display_compositor::ChildSharedBitmapManager::AllocateSharedMemory(

[danakj, 2017/02/28 20:34:57]

I don't think this is right, because this method has nothing to do with
SharedBitmaps. Either:

a) The ChildSharedBitmapManager should be somewhere else, or
b) This method should be duplicated in to ChildSharedBitmapManager (privately)
and somewhere for this to use, or
c) This method should exist where this can use it (ChildThreadImpl maybe), and
be passed in to ChildSharedBitmapManager as a function pointer?

Maybe jam@ has some opinions.

Putting the Host stuff in display_compositor seems good.

The Child stuff in display_compositor/child seems okay, but seeing as it
allocates thru mojo, maybe it should just be in cc/surfaces/? That is where
other things used by all embedders of display_compositor clients live, that
don't depend on stuff in content, which it appears to be the case now. And the
display_compositor/interfaces/ could be in cc/ipc/ then? wdyt?

[xlai (Olivia), 2017/03/01 20:02:45]

This AllocateSharedMemory is currently attached in ChildThreadImpl and
childsharedbitmapmanager uses it. Having a duplicate private
method in ChildSharedBitmapManager looks a fine approach. Or, putting the whole
chain of childSharedBitmapManager in cc/surfaces looks fine too, just need to
introduce build/build_config.h
to cc/.

I personally prefer the first approach as most users of ChildSharedBitmapManager
lies in content/child and content/renderer and this seems like just another
symmetric example as 
//components/discardable_memory/client. WDYT?

[danakj, 2017/03/03 19:21:55]

I don't think either is the right final state. cc/surfaces/ is a bit of a mix of
client and service side and we can improve that. But I don't think we should
have client stuff inside the display_compositor component, as that duplicates
the cc/surfaces problem.

John's suggestion of MojoCreateSharedBuffer() would avoid needing to duplicate
or inject AllocateSharedMemory into cc/. Though I'm not totally sure how that's
better than using mojo::SharedBufferHandle::Create tbh.

+            shared_memory_size));
     CHECK(shared_memory.get());
     if (!shared_memory->Map(shared_memory_size))
       CHECK(false);
 
     size_t remaining_bytes = length;
     const char* current_ptr = data;
     while (remaining_bytes) {
       size_t chunk_size = std::min(remaining_bytes, shared_memory_size);
       memcpy(shared_memory->memory(), current_ptr, chunk_size);
       sender_->Send(new StreamHostMsg_SyncAppendSharedMemory(
@@ skipping 71 matching lines @@
                                     expected_modification_time);
 }
 
 void WebBlobRegistryImpl::BuilderImpl::build() {
   BlobTransportController::InitiateBlobTransfer(
       uuid_, content_type_, std::move(consolidation_), sender_,
       io_runner_.get(), main_runner_);
 }
 
 }  // namespace content