Split cc::mojom::DisplayCompositor::CreateCompositorFrameSink() into CreateDisplayCompositorFrameSi…

services/ui/ws/server_window_compositor_frame_sink_manager.cc

 // Copyright 2015 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 "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 
 #include "cc/ipc/display_compositor.mojom.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "services/ui/ws/ids.h"
 #include "services/ui/ws/server_window.h"
@@ skipping 17 matching lines @@
   if (!waiting_for_initial_frames_)
     return true;
 
   waiting_for_initial_frames_ = !IsCompositorFrameSinkReadyAndNonEmpty(
                                     mojom::CompositorFrameSinkType::DEFAULT) ||
                                 !IsCompositorFrameSinkReadyAndNonEmpty(
                                     mojom::CompositorFrameSinkType::UNDERLAY);
   return !waiting_for_initial_frames_;
 }
 
-void ServerWindowCompositorFrameSinkManager::CreateCompositorFrameSink(
-    mojom::CompositorFrameSinkType compositor_frame_sink_type,
+void ServerWindowCompositorFrameSinkManager::CreateDisplayCompositorFrameSink(
     gfx::AcceleratedWidget widget,
     cc::mojom::MojoCompositorFrameSinkRequest request,
     cc::mojom::MojoCompositorFrameSinkClientPtr client) {
-  cc::FrameSinkId frame_sink_id(
-      WindowIdToTransportId(window_->id()),
-      static_cast<uint32_t>(compositor_frame_sink_type));
-  CompositorFrameSinkData& data =
-      type_to_compositor_frame_sink_map_[compositor_frame_sink_type];
-  cc::mojom::MojoCompositorFrameSinkPrivateRequest private_request;
-  if (data.pending_compositor_frame_sink_request.is_pending()) {
-    private_request = std::move(data.pending_compositor_frame_sink_request);
-  } else {
-    private_request = mojo::GetProxy(&data.compositor_frame_sink);
-  }
+  CreateCompositorFrameSinkInternal(mojom::CompositorFrameSinkType::DEFAULT,
+                                    widget, std::move(request),
+                                    std::move(client));
+}
 
-  // TODO(fsamuel): AcceleratedWidget cannot be transported over IPC for Mac or
-  // Android. We should instead use GpuSurfaceTracker here on those platforms.
-  window_->delegate()->GetDisplayCompositor()->CreateCompositorFrameSink(
-      frame_sink_id, widget, std::move(request), std::move(private_request),
-      std::move(client));
-
-  if (window_->parent()) {
-    window_->delegate()
-        ->GetRootWindow(window_)
-        ->GetOrCreateCompositorFrameSinkManager()
-        ->AddChildFrameSinkId(mojom::CompositorFrameSinkType::DEFAULT,
-                              frame_sink_id);
-  }
+void ServerWindowCompositorFrameSinkManager::CreateOffscreenCompositorFrameSink(
+    mojom::CompositorFrameSinkType compositor_frame_sink_type,
+    cc::mojom::MojoCompositorFrameSinkRequest request,
+    cc::mojom::MojoCompositorFrameSinkClientPtr client) {
+  CreateCompositorFrameSinkInternal(compositor_frame_sink_type,
+                                    gfx::kNullAcceleratedWidget,
+                                    std::move(request), std::move(client));
 }
 
 void ServerWindowCompositorFrameSinkManager::AddChildFrameSinkId(
     mojom::CompositorFrameSinkType compositor_frame_sink_type,
     const cc::FrameSinkId& frame_sink_id) {
   auto it = type_to_compositor_frame_sink_map_.find(compositor_frame_sink_type);
   if (it != type_to_compositor_frame_sink_map_.end()) {
     it->second.compositor_frame_sink->AddChildFrameSink(frame_sink_id);
     return;
   }
@@ skipping 57 matching lines @@
   if (iter == type_to_compositor_frame_sink_map_.end())
     return false;
   if (iter->second.latest_submitted_frame_size.IsEmpty())
     return false;
   const gfx::Size& latest_submitted_frame_size =
       iter->second.latest_submitted_frame_size;
   return latest_submitted_frame_size.width() >= window_->bounds().width() &&
          latest_submitted_frame_size.height() >= window_->bounds().height();
 }
 
+void ServerWindowCompositorFrameSinkManager::CreateCompositorFrameSinkInternal(
+    mojom::CompositorFrameSinkType compositor_frame_sink_type,
+    gfx::AcceleratedWidget widget,
+    cc::mojom::MojoCompositorFrameSinkRequest request,
+    cc::mojom::MojoCompositorFrameSinkClientPtr client) {
+  cc::FrameSinkId frame_sink_id(
+      WindowIdToTransportId(window_->id()),
+      static_cast<uint32_t>(compositor_frame_sink_type));
+  CompositorFrameSinkData& data =
+      type_to_compositor_frame_sink_map_[compositor_frame_sink_type];
+  cc::mojom::MojoCompositorFrameSinkPrivateRequest private_request;
+  if (data.pending_compositor_frame_sink_request.is_pending()) {
+    private_request = std::move(data.pending_compositor_frame_sink_request);
+  } else {
+    private_request = mojo::GetProxy(&data.compositor_frame_sink);
+  }
+
+  if (widget != gfx::kNullAcceleratedWidget) {
+    // TODO(fsamuel): AcceleratedWidget cannot be transported over IPC for Mac
+    // or Android. We should instead use GpuSurfaceTracker here on those
+    // platforms.
+    window_->delegate()
+        ->GetDisplayCompositor()
+        ->CreateDisplayCompositorFrameSink(
+            frame_sink_id, widget, std::move(request),
+            std::move(private_request), std::move(client));
+  } else {
+    window_->delegate()
+        ->GetDisplayCompositor()
+        ->CreateOffscreenCompositorFrameSink(frame_sink_id, std::move(request),
+                                             std::move(private_request),
+                                             std::move(client));
+  }
+
+  if (window_->parent()) {
+    window_->delegate()
+        ->GetRootWindow(window_)
+        ->GetOrCreateCompositorFrameSinkManager()
+        ->AddChildFrameSinkId(mojom::CompositorFrameSinkType::DEFAULT,
+                              frame_sink_id);
+  }
+}
+
 CompositorFrameSinkData::CompositorFrameSinkData() {}
 
 CompositorFrameSinkData::~CompositorFrameSinkData() {}
 
 CompositorFrameSinkData::CompositorFrameSinkData(
     CompositorFrameSinkData&& other)
     : latest_submitted_surface_id(other.latest_submitted_surface_id),
       compositor_frame_sink(std::move(other.compositor_frame_sink)) {}
 
 CompositorFrameSinkData& CompositorFrameSinkData::operator=(
     CompositorFrameSinkData&& other) {
   latest_submitted_surface_id = other.latest_submitted_surface_id;
   compositor_frame_sink = std::move(other.compositor_frame_sink);
   return *this;
 }
 
 }  // namespace ws
 }  // namespace ui