discardable_memory: Using mojo IPC to replace Chrome IPC

content/renderer/render_thread_impl.cc

 // Copyright (c) 2012 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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 863 matching lines @@
       base::StringToInt(string_value, &num_raster_threads);
   DCHECK(parsed_num_raster_threads) << string_value;
   DCHECK_GT(num_raster_threads, 0);
 
   // TODO(vmpstr): If the flag sticks, we should clean it up and always have
   // image decode tasks.
   are_image_decode_tasks_enabled_ = true;
 
   categorized_worker_pool_->Start(num_raster_threads);
 
+  discardable_memory::mojom::DiscardableSharedMemoryManagerPtr manager_ptr;
+  ChildThread::Get()->GetRemoteInterfaces()->GetInterface(
+      mojo::GetProxy(&manager_ptr));
+  discardable_shared_memory_manager_ = base::MakeUnique<
+      discardable_memory::ClientDiscardableSharedMemoryManager>(
+      std::move(manager_ptr), GetIOTaskRunner());
+
   // TODO(boliu): In single process, browser main loop should set up the
   // discardable memory manager, and should skip this if kSingleProcess.
   // See crbug.com/503724.
   base::DiscardableMemoryAllocator::SetInstance(
-      ChildThreadImpl::discardable_shared_memory_manager());
+      discardable_shared_memory_manager_.get());
 
   GetContentClient()->renderer()->ExposeInterfacesToBrowser(
       GetInterfaceRegistry());
 
   GetInterfaceRegistry()->AddInterface(base::Bind(&CreateFrameFactory));
   GetInterfaceRegistry()->AddInterface(base::Bind(&CreateEmbeddedWorkerSetup));
   GetInterfaceRegistry()->AddInterface(
       base::Bind(&EmbeddedWorkerInstanceClientImpl::Create,
                  base::Unretained(embedded_worker_dispatcher_.get())));
 
@@ skipping 134 matching lines @@
     blink_platform_impl_->Shutdown();
     // This must be at the very end of the shutdown sequence.
     // blink::shutdown() must be called after all strong references from
     // Chromium to Blink are cleared.
     blink::shutdown();
   }
 
   // Delay shutting down DiscardableSharedMemoryManager until blink::shutdown
   // is complete, because blink::shutdown destructs Blink Resources and they
   // may try to unlock their underlying discardable memory.
-  ChildThreadImpl::ShutdownDiscardableSharedMemoryManager();
+  discardable_shared_memory_manager_.reset();
 
   // The message loop must be cleared after shutting down
   // the DiscardableSharedMemoryManager, which needs to send messages
   // to the browser process.
   main_message_loop_.reset();
 
   lazy_tls.Pointer()->Set(nullptr);
 
   base::MemoryCoordinatorClientRegistry::GetInstance()->Unregister(this);
 }
@@ skipping 806 matching lines @@
 #else
   size_t malloc_usage = minfo.hblkhd + minfo.arena;
 #endif
 #else
   size_t malloc_usage = GetMallocUsage();
 #endif
   UMA_HISTOGRAM_MEMORY_MB("PurgeAndSuspend.Memory.MallocMB",
                           malloc_usage / 1024 / 1024);
 
   discardable_memory::ClientDiscardableSharedMemoryManager::Statistics
-      discardable_stats =
-          ChildThreadImpl::discardable_shared_memory_manager()->GetStatistics();
+      discardable_stats = discardable_shared_memory_manager_->GetStatistics();
   size_t discardable_usage =
       discardable_stats.total_size - discardable_stats.freelist_size;
   UMA_HISTOGRAM_MEMORY_KB("PurgeAndSuspend.Memory.DiscardableKB",
                           discardable_usage / 1024);
 
   size_t v8_usage = 0;
   if (v8::Isolate* isolate = blink::mainThreadIsolate()) {
     v8::HeapStatistics v8_heap_statistics;
     isolate->GetHeapStatistics(&v8_heap_statistics);
     v8_usage = v8_heap_statistics.total_heap_size();
@@ skipping 554 matching lines @@
 
 void RenderThreadImpl::OnRendererVisible() {
   blink::mainThreadIsolate()->IsolateInForegroundNotification();
   if (!GetContentClient()->renderer()->RunIdleHandlerWhenWidgetsHidden())
     return;
   ScheduleIdleHandler(kLongIdleHandlerDelayMs);
 }
 
 void RenderThreadImpl::ReleaseFreeMemory() {
   base::allocator::ReleaseFreeMemory();
-  discardable_shared_memory_manager()->ReleaseFreeMemory();
+  discardable_shared_memory_manager_->ReleaseFreeMemory();
 
   if (blink_platform_impl_)
     blink::decommitFreeableMemory();
 }
 
 RenderThreadImpl::PendingFrameCreate::PendingFrameCreate(
     int routing_id,
     mojom::FrameRequest frame_request,
     mojom::FrameHostPtr frame_host)
     : routing_id_(routing_id),
@@ skipping 47 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content