content: Pass IOSurface references using Mach IPC.

content/browser/browser_io_surface_manager_mac_unittest.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 "content/browser/browser_io_surface_manager_mac.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+
+class BrowserIOSurfaceManagerTest : public testing::Test {
+ public:
+  void EnsureRunning() { io_surface_manager_.EnsureRunning(); }
+
+  IOSurfaceManagerToken GetGpuProcessToken() const {
+    return io_surface_manager_.GetGpuProcessToken();
+  }
+
+  IOSurfaceManagerToken GenerateChildProcessToken(int child_process_id) {
+    return io_surface_manager_.GenerateChildProcessToken(child_process_id);
+  }
+
+  void InvalidateChildProcessToken(const IOSurfaceManagerToken& token) {
+    io_surface_manager_.InvalidateChildProcessToken(token);
+  }
+
+  bool HandleRegisterIOSurfaceRequest(
+      const IOSurfaceManagerHostMsg_RegisterIOSurface& request,
+      IOSurfaceManagerMsg_RegisterIOSurfaceReply* reply) {
+    return io_surface_manager_.HandleRegisterIOSurfaceRequest(request, reply);
+  }
+
+  bool HandleUnregisterIOSurfaceRequest(
+      const IOSurfaceManagerHostMsg_UnregisterIOSurface& request) {
+    return io_surface_manager_.HandleUnregisterIOSurfaceRequest(request);
+  }
+
+  bool HandleAcquireIOSurfaceRequest(
+      const IOSurfaceManagerHostMsg_AcquireIOSurface& request,
+      IOSurfaceManagerMsg_AcquireIOSurfaceReply* reply) {
+    return io_surface_manager_.HandleAcquireIOSurfaceRequest(request, reply);
+  }
+
+ private:
+  BrowserIOSurfaceManager io_surface_manager_;
+};
+
+TEST_F(BrowserIOSurfaceManagerTest, EnsureRunning) {
+  EnsureRunning();
+  base::mac::ScopedMachSendRight service_port =
+      BrowserIOSurfaceManager::LookupServicePort(getpid());
+  EXPECT_TRUE(service_port.is_valid());
+}
+
+TEST_F(BrowserIOSurfaceManagerTest, IOSurfaceRegistration) {
+  const int kIOSurfaceId = 1;
+  const int kClientId = 1;
+
+  IOSurfaceManagerToken child_process_token =
+      GenerateChildProcessToken(kClientId);
+
+  {
+    IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
+    IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
+
+    request.io_surface_id = kIOSurfaceId;
+    request.client_id = kClientId;
+
+    // Fails as request doesn't contain valid token.
+    EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
+
+    memcpy(request.token_name, child_process_token.name,
+           sizeof(child_process_token.name));
+    // Fails as child process is not allowed to register IOSurfaces.
+    EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
+
+    IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
+    memcpy(request.token_name, gpu_process_token.name,
+           sizeof(gpu_process_token.name));
+    EXPECT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
+    EXPECT_TRUE(reply.result);
+  }

[Robert Sesek, 2015/05/28 18:25:11]

Since there's not much shared setup between these scope blocks, it's better to
create individual TEST_F()s for different cases. It makes it more clear what
specific behavior is broken when a test fails.

[reveman, 2015/05/29 00:09:02]

Done.

[Robert Sesek, 2015/06/01 21:58:06]

Really? There's still a bunch of different test cases running all under the same
TEST_F. Particularly in AcquireIOSurface.

[reveman, 2015/06/02 22:48:07]

Sorry, misunderstood your previous comment. Thought you were only talking about
how IOSurfaceRegistration was testing both RegisterIOSurface and
UnregisterIOSurface. I've split this up into a number of different tests in
latest patch. PTAL.

+
+  {
+    IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
+
+    request.io_surface_id = kIOSurfaceId;
+    request.client_id = kClientId;
+
+    // Fails as request doesn't contain valid GPU token.
+    EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
+
+    memcpy(request.token_name, child_process_token.name,
+           sizeof(child_process_token.name));
+    // Fails as child process is not allowed to unregister IOSurfaces.
+    EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
+
+    IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
+    memcpy(request.token_name, gpu_process_token.name,
+           sizeof(gpu_process_token.name));
+    EXPECT_TRUE(HandleUnregisterIOSurfaceRequest(request));
+  }
+}
+
+TEST_F(BrowserIOSurfaceManagerTest, AcquireIOSurface) {
+  const int kIOSurfaceId1 = 10;
+  const int kIOSurfaceId2 = 20;
+  const int kClientId1 = 1;
+  const int kClientId2 = 2;
+  const mach_port_t kIOSurfacePortId1 = 100u;
+  const mach_port_t kIOSurfacePortId2 = 200u;
+
+  IOSurfaceManagerToken child_process_token1 =
+      GenerateChildProcessToken(kClientId1);
+  IOSurfaceManagerToken child_process_token2 =
+      GenerateChildProcessToken(kClientId2);
+
+  {
+    IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
+    IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
+
+    // Register IOSurface for use by kClientId1.
+    request.io_surface_id = kIOSurfaceId1;
+    request.client_id = kClientId1;
+    request.io_surface_port.name = kIOSurfacePortId1;
+    IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
+    memcpy(request.token_name, gpu_process_token.name,
+           sizeof(gpu_process_token.name));
+    EXPECT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
+    EXPECT_TRUE(reply.result);
+  }
+
+  {
+    IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
+    IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
+
+    // Register IOSurface for use by kClientId2.
+    request.io_surface_id = kIOSurfaceId2;
+    request.client_id = kClientId2;
+    request.io_surface_port.name = kIOSurfacePortId2;
+    IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
+    memcpy(request.token_name, gpu_process_token.name,
+           sizeof(gpu_process_token.name));
+    EXPECT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
+    EXPECT_TRUE(reply.result);
+  }
+
+  {
+    IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
+    IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
+
+    request.io_surface_id = kIOSurfaceId2;
+
+    // Fails as request doesn't contain valid token.
+    EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
+
+    memcpy(request.token_name, child_process_token1.name,
+           sizeof(child_process_token1.name));
+    // Fails as child process 1 is not allowed to acquire this IOSurface.
+    EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
+
+    request.io_surface_id = kIOSurfaceId1;
+    EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
+    EXPECT_EQ(kIOSurfacePortId1, reply.io_surface_port.name);
+  }
+
+  {
+    IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
+    IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
+
+    request.io_surface_id = kIOSurfaceId2;
+
+    memcpy(request.token_name, child_process_token2.name,
+           sizeof(child_process_token2.name));
+    EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
+    EXPECT_EQ(kIOSurfacePortId2, reply.io_surface_port.name);
+  }
+
+  InvalidateChildProcessToken(child_process_token2);
+
+  {
+    IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
+    IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
+
+    request.io_surface_id = kIOSurfaceId2;
+
+    memcpy(request.token_name, child_process_token2.name,
+           sizeof(child_process_token2.name));
+    // Fails as as token is no longer valid.
+    EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
+  }
+}
+
+}  // namespace content