content/browser/browser_io_surface_manager_mac_unittest.cc

   1 // Copyright 2015 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/browser_io_surface_manager_mac.h"
   6
   7 #include "testing/gtest/include/gtest/gtest.h"
   8
   9 namespace content {
  10
  11 class BrowserIOSurfaceManagerTest : public testing::Test {
  12  public:
  13   void EnsureRunning() { io_surface_manager_.EnsureRunning(); }
  14
  15   IOSurfaceManagerToken GenerateGpuProcessToken() {
  16     return io_surface_manager_.GenerateGpuProcessToken();
  17   }
  18
  19   void InvalidateGpuProcessToken() {
  20     io_surface_manager_.InvalidateGpuProcessToken();
  21   }
  22
  23   IOSurfaceManagerToken GenerateChildProcessToken(int child_process_id) {
  24     return io_surface_manager_.GenerateChildProcessToken(child_process_id);
  25   }
  26
  27   void InvalidateChildProcessToken(const IOSurfaceManagerToken& token) {
  28     io_surface_manager_.InvalidateChildProcessToken(token);
  29   }
  30
  31   bool HandleRegisterIOSurfaceRequest(
  32       const IOSurfaceManagerHostMsg_RegisterIOSurface& request,
  33       IOSurfaceManagerMsg_RegisterIOSurfaceReply* reply) {
  34     io_surface_manager_.HandleRegisterIOSurfaceRequest(request, reply);
  35     return reply->result;
  36   }
  37
  38   bool HandleUnregisterIOSurfaceRequest(
  39       const IOSurfaceManagerHostMsg_UnregisterIOSurface& request) {
  40     return io_surface_manager_.HandleUnregisterIOSurfaceRequest(request);
  41   }
  42
  43   bool HandleAcquireIOSurfaceRequest(
  44       const IOSurfaceManagerHostMsg_AcquireIOSurface& request,
  45       IOSurfaceManagerMsg_AcquireIOSurfaceReply* reply) {
  46     io_surface_manager_.HandleAcquireIOSurfaceRequest(request, reply);
  47     return reply->result;
  48   }
  49
  50   // Helper function used to register an IOSurface for testing.
  51   void RegisterIOSurface(const IOSurfaceManagerToken& gpu_process_token,
  52                          int io_surface_id,
  53                          int client_id,
  54                          mach_port_t io_surface_port) {
  55     IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  56     IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
  57     request.io_surface_id = io_surface_id;
  58     request.client_id = client_id;
  59     request.io_surface_port.name = io_surface_port;
  60     memcpy(request.token_name, gpu_process_token.name,
  61            sizeof(gpu_process_token.name));
  62     ASSERT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
  63     ASSERT_TRUE(reply.result);
  64   }
  65
  66  private:
  67   BrowserIOSurfaceManager io_surface_manager_;
  68 };
  69
  70 TEST_F(BrowserIOSurfaceManagerTest, EnsureRunning) {
  71   EnsureRunning();
  72   base::mac::ScopedMachSendRight service_port =
  73       BrowserIOSurfaceManager::LookupServicePort(getpid());
  74   EXPECT_TRUE(service_port.is_valid());
  75 }
  76
  77 TEST_F(BrowserIOSurfaceManagerTest, RegisterIOSurfaceSucceeds) {
  78   const int kIOSurfaceId = 1;
  79   const int kClientId = 1;
  80
  81   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
  82
  83   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  84   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
  85
  86   request.io_surface_id = kIOSurfaceId;
  87   request.client_id = kClientId;
  88   memcpy(request.token_name, gpu_process_token.name,
  89          sizeof(gpu_process_token.name));
  90   EXPECT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
  91   EXPECT_TRUE(reply.result);
  92 }
  93
  94 TEST_F(BrowserIOSurfaceManagerTest, RegisterIOSurfaceFailsWithInvalidToken) {
  95   const int kIOSurfaceId = 1;
  96   const int kClientId = 1;
  97
  98   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  99   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
 100   request.io_surface_id = kIOSurfaceId;
 101   request.client_id = kClientId;
 102   // Fails as request doesn't contain a valid token.
 103   EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
 104 }
 105
 106 TEST_F(BrowserIOSurfaceManagerTest,
 107        RegisterIOSurfaceFailsWithChildProcessToken) {
 108   const int kIOSurfaceId = 1;
 109   const int kClientId = 1;
 110
 111   IOSurfaceManagerToken child_process_token =
 112       GenerateChildProcessToken(kClientId);
 113
 114   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
 115   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
 116   request.io_surface_id = kIOSurfaceId;
 117   request.client_id = kClientId;
 118   memcpy(request.token_name, child_process_token.name,
 119          sizeof(child_process_token.name));
 120   // Fails as child process is not allowed to register IOSurfaces.
 121   EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
 122 }
 123
 124 TEST_F(BrowserIOSurfaceManagerTest, UnregisterIOSurfaceSucceeds) {
 125   const int kIOSurfaceId = 1;
 126   const int kClientId = 1;
 127
 128   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 129
 130   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId, 0);
 131
 132   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 133   request.io_surface_id = kIOSurfaceId;
 134   request.client_id = kClientId;
 135   memcpy(request.token_name, gpu_process_token.name,
 136          sizeof(gpu_process_token.name));
 137   EXPECT_TRUE(HandleUnregisterIOSurfaceRequest(request));
 138 }
 139
 140 TEST_F(BrowserIOSurfaceManagerTest, UnregisterIOSurfaceFailsWithInvalidToken) {
 141   const int kIOSurfaceId = 1;
 142   const int kClientId = 1;
 143
 144   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 145
 146   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId, 0);
 147
 148   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 149   request.io_surface_id = kIOSurfaceId;
 150   request.client_id = kClientId;
 151   // Fails as request doesn't contain valid GPU token.
 152   EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
 153 }
 154
 155 TEST_F(BrowserIOSurfaceManagerTest,
 156        UnregisterIOSurfaceFailsWithChildProcessToken) {
 157   const int kIOSurfaceId = 1;
 158   const int kClientId = 1;
 159
 160   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 161   IOSurfaceManagerToken child_process_token =
 162       GenerateChildProcessToken(kClientId);
 163
 164   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId, 0);
 165
 166   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 167   request.io_surface_id = kIOSurfaceId;
 168   request.client_id = kClientId;
 169   memcpy(request.token_name, child_process_token.name,
 170          sizeof(child_process_token.name));
 171   // Fails as child process is not allowed to unregister IOSurfaces.
 172   EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
 173 }
 174
 175 TEST_F(BrowserIOSurfaceManagerTest, AcquireIOSurfaceSucceeds) {
 176   const int kIOSurfaceId = 10;
 177   const int kClientId = 1;
 178   const mach_port_t kIOSurfacePortId = 100u;
 179
 180   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 181   IOSurfaceManagerToken child_process_token =
 182       GenerateChildProcessToken(kClientId);
 183
 184   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId,
 185                     kIOSurfacePortId);
 186
 187   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 188   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 189   request.io_surface_id = kIOSurfaceId;
 190   memcpy(request.token_name, child_process_token.name,
 191          sizeof(child_process_token.name));
 192   EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
 193   EXPECT_EQ(kIOSurfacePortId, reply.io_surface_port.name);
 194 }
 195
 196 TEST_F(BrowserIOSurfaceManagerTest, AcquireIOSurfaceFailsWithInvalidToken) {
 197   const int kIOSurfaceId = 10;
 198   const int kClientId = 1;
 199   const mach_port_t kIOSurfacePortId = 100u;
 200
 201   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 202
 203   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId,
 204                     kIOSurfacePortId);
 205
 206   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 207   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 208   request.io_surface_id = kIOSurfaceId;
 209   // Fails as request doesn't contain valid token.
 210   EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
 211 }
 212
 213 TEST_F(BrowserIOSurfaceManagerTest,
 214        AcquireIOSurfaceFailsWithWrongChildProcessToken) {
 215   const int kIOSurfaceId = 10;
 216   const int kClientId1 = 1;
 217   const int kClientId2 = 2;
 218   const mach_port_t kIOSurfacePortId = 100u;
 219
 220   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 221   IOSurfaceManagerToken child_process_token2 =
 222       GenerateChildProcessToken(kClientId2);
 223
 224   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId1,
 225                     kIOSurfacePortId);
 226
 227   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 228   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 229   request.io_surface_id = kIOSurfaceId;
 230   memcpy(request.token_name, child_process_token2.name,
 231          sizeof(child_process_token2.name));
 232   EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
 233   // Fails as child process 2 is not allowed to acquire this IOSurface.
 234   EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
 235             reply.io_surface_port.name);
 236 }
 237
 238 TEST_F(BrowserIOSurfaceManagerTest,
 239        AcquireIOSurfaceFailsAfterInvalidatingChildProcessToken) {
 240   const int kIOSurfaceId = 10;
 241   const int kClientId = 1;
 242   const mach_port_t kIOSurfacePortId = 100u;
 243
 244   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 245   IOSurfaceManagerToken child_process_token =
 246       GenerateChildProcessToken(kClientId);
 247
 248   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId,
 249                     kIOSurfacePortId);
 250
 251   InvalidateChildProcessToken(child_process_token);
 252
 253   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 254   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 255   request.io_surface_id = kIOSurfaceId;
 256   memcpy(request.token_name, child_process_token.name,
 257          sizeof(child_process_token.name));
 258   // Fails as token is no longer valid.
 259   EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
 260 }
 261
 262 TEST_F(BrowserIOSurfaceManagerTest,
 263        AcquireIOSurfaceAfterInvalidatingGpuProcessToken) {
 264   const int kIOSurfaceId = 10;
 265   const int kClientId = 1;
 266   const mach_port_t kIOSurfacePortId = 100u;
 267
 268   IOSurfaceManagerToken gpu_process_token = GenerateGpuProcessToken();
 269   IOSurfaceManagerToken child_process_token =
 270       GenerateChildProcessToken(kClientId);
 271
 272   RegisterIOSurface(gpu_process_token, kIOSurfaceId, kClientId,
 273                     kIOSurfacePortId);
 274
 275   InvalidateGpuProcessToken();
 276
 277   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 278   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 279   request.io_surface_id = kIOSurfaceId;
 280   memcpy(request.token_name, child_process_token.name,
 281          sizeof(child_process_token.name));
 282   EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
 283   // Should return invalid port.
 284   EXPECT_EQ(static_cast<mach_port_t>(MACH_PORT_NULL),
 285             reply.io_surface_port.name);
 286 }
 287
 288 }  // namespace content