Hosting the discardable memory service in the mus process

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 124 matching lines @@
 #include "media/base/media.h"
 #include "media/media_features.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "net/base/net_errors.h"
 #include "net/base/port_util.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "net/base/url_util.h"
 #include "ppapi/features/features.h"
+#include "services/service_manager/public/cpp/connector.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/public/cpp/interface_registry.h"
+#include "services/ui/public/interfaces/constants.mojom.h"
 #include "skia/ext/event_tracer_impl.h"
 #include "skia/ext/skia_memory_dump_provider.h"
 #include "third_party/WebKit/public/platform/WebImageGenerator.h"
 #include "third_party/WebKit/public/platform/WebMemoryCoordinator.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/scheduler/child/compositor_worker_scheduler.h"
 #include "third_party/WebKit/public/platform/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebCache.h"
@@ skipping 491 matching lines @@
   blink::WebView::setUseExternalPopupMenus(true);
 #endif
 
   lazy_tls.Pointer()->Set(this);
 
   // Register this object as the main thread.
   ChildProcess::current()->set_main_thread(this);
 
 #if defined(USE_AURA)
   if (IsRunningInMash()) {
-    gpu_service_ =
-        ui::GpuService::Create(GetServiceManagerConnection()->GetConnector(),
-                               ChildProcess::current()->io_task_runner());
+    gpu_service_ = ui::GpuService::Create(
+        GetServiceManagerConnection()->GetConnector(), GetIOTaskRunner());
   }
 #endif
   gpu_memory_buffer_manager_ =
       base::MakeUnique<ChildGpuMemoryBufferManager>(thread_safe_sender());
 
   thread_safe_associated_interface_ptr_provider_ =
       base::MakeUnique<ThreadSafeAssociatedInterfacePtrProvider>(channel());
   thread_safe_render_message_filter_ =
       thread_safe_associated_interface_ptr_provider_
           ->CreateInterfacePtr<mojom::RenderMessageFilter>();
@@ skipping 206 matching lines @@
   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));
+  bool manager_initialized = false;
+#if defined(USE_AURA)
+  if (IsRunningInMash()) {
+    GetServiceManagerConnection()->GetConnector()->ConnectToInterface(
+        ui::mojom::kServiceName, &manager_ptr);
+    manager_initialized = true;
+  }
+#endif
+  if (!manager_initialized) {

[sadrul, 2016/12/07 17:56:40]

Do you need |manager_initialized|? Can you check |manager_ptr| instead?

[Peng, 2016/12/07 19:02:05]

Seems ConnectToInterface() can be failed, so probably it is better remove #if
define(), and always check IsRunningInMash().

+    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(
       discardable_shared_memory_manager_.get());
 
@@ skipping 1613 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content