Use MojoCompositorFrameSink in RendererCompositorFrameSink

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 232 matching lines @@
 const int kMaxResourceRequestsPerFlushWhenThrottled = 8;
 #endif
 const double kThrottledResourceRequestFlushPeriodS = 1. / 60.;
 
 // Maximum allocation size allowed for image scaling filters that
 // require pre-scaling. Skia will fallback to a filter that doesn't
 // require pre-scaling if the default filter would require an
 // allocation that exceeds this limit.
 const size_t kImageCacheSingleAllocationByteLimit = 64 * 1024 * 1024;
 
+#if defined(OS_ANDROID)
 // Unique identifier for each output surface created.
 uint32_t g_next_compositor_frame_sink_id = 1;
+#endif
 
 // An implementation of mojom::RenderMessageFilter which can be mocked out
 // for tests which may indirectly send messages over this interface.
 mojom::RenderMessageFilter* g_render_message_filter_for_testing;
 
 // Keep the global RenderThreadImpl in a TLS slot so it is impossible to access
 // incorrectly from the wrong thread.
 base::LazyInstance<base::ThreadLocalPointer<RenderThreadImpl>>::DestructorAtExit
     lazy_tls = LAZY_INSTANCE_INITIALIZER;
 
@@ skipping 620 matching lines @@
   needs_to_record_first_active_paint_ = false;
 
   base::MemoryCoordinatorClientRegistry::GetInstance()->Register(this);
 
   // If this renderer doesn't run inside the browser process, enable
   // SequencedWorkerPool. Otherwise, it should already have been enabled.
   // TODO(fdoray): Remove this once the SequencedWorkerPool to TaskScheduler
   // redirection experiment concludes https://crbug.com/622400.
   if (!command_line.HasSwitch(switches::kSingleProcess))
     base::SequencedWorkerPool::EnableForProcess();
+
+  GetConnector()->BindInterface(mojom::kBrowserServiceName,
+                                mojo::MakeRequest(&frame_sink_provider_));
 }
 
 RenderThreadImpl::~RenderThreadImpl() {
 }
 
 void RenderThreadImpl::Shutdown() {
   // In a multi-process mode, we immediately exit the renderer.
   // Historically we had a graceful shutdown sequence here but it was
   // 1) a waste of performance and 2) a source of lots of complicated
   // crashes caused by shutdown ordering. Immediate exit eliminates
@@ skipping 983 matching lines @@
       return;
     }
     RendererWindowTreeClient::Get(routing_id)
         ->RequestCompositorFrameSink(
             gpu_->CreateContextProvider(std::move(channel)),
             GetGpuMemoryBufferManager(), callback);
     return;
   }
 #endif
 
-  uint32_t compositor_frame_sink_id = g_next_compositor_frame_sink_id++;
-
   if (command_line.HasSwitch(switches::kEnableVulkan)) {
     scoped_refptr<cc::VulkanContextProvider> vulkan_context_provider =
         cc::VulkanInProcessContextProvider::Create();
     if (vulkan_context_provider) {
       DCHECK(!layout_test_mode());
       callback.Run(base::MakeUnique<RendererCompositorFrameSink>(
-          routing_id, compositor_frame_sink_id,
-          std::move(synthetic_begin_frame_source),
+          routing_id, std::move(synthetic_begin_frame_source),
           std::move(vulkan_context_provider),
           std::move(frame_swap_message_queue)));
       return;
     }
   }
 
   // Create a gpu process channel and verify we want to use GPU compositing
   // before creating any context providers.
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
   if (!use_software) {
     gpu_channel_host = EstablishGpuChannelSync();
     if (!gpu_channel_host) {
       // Cause the compositor to wait and try again.
       callback.Run(nullptr);
       return;
     }
     // We may get a valid channel, but with a software renderer. In that case,
     // disable GPU compositing.
     if (gpu_channel_host->gpu_info().software_rendering)
       use_software = true;
   }
 
   if (use_software) {
     DCHECK(!layout_test_mode());
     callback.Run(base::MakeUnique<RendererCompositorFrameSink>(
-        routing_id, compositor_frame_sink_id,
-        std::move(synthetic_begin_frame_source), nullptr, nullptr, nullptr,
-        shared_bitmap_manager(), std::move(frame_swap_message_queue)));
+        routing_id, std::move(synthetic_begin_frame_source), nullptr, nullptr,
+        nullptr, shared_bitmap_manager(), std::move(frame_swap_message_queue)));
     return;
   }
 
   scoped_refptr<ui::ContextProviderCommandBuffer> worker_context_provider =
       SharedCompositorWorkerContextProvider();
   if (!worker_context_provider) {
     // Cause the compositor to wait and try again.
     callback.Run(nullptr);
     return;
   }
@@ skipping 40 matching lines @@
 
 #if defined(OS_ANDROID)
   if (sync_compositor_message_filter_) {
     std::unique_ptr<cc::BeginFrameSource> begin_frame_source =
         synthetic_begin_frame_source
             ? std::move(synthetic_begin_frame_source)
             : CreateExternalBeginFrameSource(routing_id);
     callback.Run(base::MakeUnique<SynchronousCompositorFrameSink>(
         std::move(context_provider), std::move(worker_context_provider),
         GetGpuMemoryBufferManager(), shared_bitmap_manager(), routing_id,
-        compositor_frame_sink_id, std::move(begin_frame_source),
+        g_next_compositor_frame_sink_id++, std::move(begin_frame_source),
         sync_compositor_message_filter_.get(),
         std::move(frame_swap_message_queue)));
     return;
   }
 #endif
   callback.Run(base::WrapUnique(new RendererCompositorFrameSink(
-      routing_id, compositor_frame_sink_id,
-      std::move(synthetic_begin_frame_source), std::move(context_provider),
-      std::move(worker_context_provider), GetGpuMemoryBufferManager(), nullptr,
+      routing_id, std::move(synthetic_begin_frame_source),
+      std::move(context_provider), std::move(worker_context_provider),
+      GetGpuMemoryBufferManager(), nullptr,
       std::move(frame_swap_message_queue))));
 }
 
 AssociatedInterfaceRegistry*
 RenderThreadImpl::GetAssociatedInterfaceRegistry() {
   return &associated_interfaces_;
 }
 
 std::unique_ptr<cc::SwapPromise>
 RenderThreadImpl::RequestCopyOfOutputForLayoutTest(
@@ skipping 433 matching lines @@
   }
 }
 
 void RenderThreadImpl::OnRendererInterfaceRequest(
     mojom::RendererAssociatedRequest request) {
   DCHECK(!renderer_binding_.is_bound());
   renderer_binding_.Bind(std::move(request));
 }
 
 }  // namespace content