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 GetGpuProcessToken() const {
  16     return io_surface_manager_.GetGpuProcessToken();
  17   }
  18
  19   IOSurfaceManagerToken GenerateChildProcessToken(int child_process_id) {
  20     return io_surface_manager_.GenerateChildProcessToken(child_process_id);
  21   }
  22
  23   void InvalidateChildProcessToken(const IOSurfaceManagerToken& token) {
  24     io_surface_manager_.InvalidateChildProcessToken(token);
  25   }
  26
  27   bool HandleRegisterIOSurfaceRequest(
  28       const IOSurfaceManagerHostMsg_RegisterIOSurface& request,
  29       IOSurfaceManagerMsg_RegisterIOSurfaceReply* reply) {
  30     return io_surface_manager_.HandleRegisterIOSurfaceRequest(request, reply);
  31   }
  32
  33   bool HandleUnregisterIOSurfaceRequest(
  34       const IOSurfaceManagerHostMsg_UnregisterIOSurface& request) {
  35     return io_surface_manager_.HandleUnregisterIOSurfaceRequest(request);
  36   }
  37
  38   bool HandleAcquireIOSurfaceRequest(
  39       const IOSurfaceManagerHostMsg_AcquireIOSurface& request,
  40       IOSurfaceManagerMsg_AcquireIOSurfaceReply* reply) {
  41     return io_surface_manager_.HandleAcquireIOSurfaceRequest(request, reply);
  42   }
  43
  44   // Helper function used to register an IOSurface for testing.
  45   void RegisterIOSurface(int io_surface_id,
  46                          int client_id,
  47                          mach_port_t io_surface_port) {
  48     IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
  49     IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  50     IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
  51     request.io_surface_id = io_surface_id;
  52     request.client_id = client_id;
  53     request.io_surface_port.name = io_surface_port;
  54     memcpy(request.token_name, gpu_process_token.name,
  55            sizeof(gpu_process_token.name));
  56     ASSERT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
  57     ASSERT_TRUE(reply.result);
  58   }
  59
  60  private:
  61   BrowserIOSurfaceManager io_surface_manager_;
  62 };
  63
  64 TEST_F(BrowserIOSurfaceManagerTest, EnsureRunning) {
  65   EnsureRunning();
  66   base::mac::ScopedMachSendRight service_port =
  67       BrowserIOSurfaceManager::LookupServicePort(getpid());
  68   EXPECT_TRUE(service_port.is_valid());
  69 }
  70
  71 TEST_F(BrowserIOSurfaceManagerTest, RegisterIOSurfaceSucceeds) {
  72   const int kIOSurfaceId = 1;
  73   const int kClientId = 1;
  74
  75   IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
  76
  77   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  78   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
  79
  80   request.io_surface_id = kIOSurfaceId;
  81   request.client_id = kClientId;
  82   memcpy(request.token_name, gpu_process_token.name,
  83          sizeof(gpu_process_token.name));
  84   EXPECT_TRUE(HandleRegisterIOSurfaceRequest(request, &reply));
  85   EXPECT_TRUE(reply.result);
  86 }
  87
  88 TEST_F(BrowserIOSurfaceManagerTest, RegisterIOSurfaceFailsWithInvalidToken) {
  89   const int kIOSurfaceId = 1;
  90   const int kClientId = 1;
  91
  92   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
  93   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
  94   request.io_surface_id = kIOSurfaceId;
  95   request.client_id = kClientId;
  96   // Fails as request doesn't contain a valid token.
  97   EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
  98 }
  99
 100 TEST_F(BrowserIOSurfaceManagerTest,
 101        RegisterIOSurfaceFailsWithChildProcessToken) {
 102   const int kIOSurfaceId = 1;
 103   const int kClientId = 1;
 104
 105   IOSurfaceManagerToken child_process_token =
 106       GenerateChildProcessToken(kClientId);
 107
 108   IOSurfaceManagerHostMsg_RegisterIOSurface request = {{0}};
 109   IOSurfaceManagerMsg_RegisterIOSurfaceReply reply = {{0}};
 110   request.io_surface_id = kIOSurfaceId;
 111   request.client_id = kClientId;
 112   memcpy(request.token_name, child_process_token.name,
 113          sizeof(child_process_token.name));
 114   // Fails as child process is not allowed to register IOSurfaces.
 115   EXPECT_FALSE(HandleRegisterIOSurfaceRequest(request, &reply));
 116 }
 117
 118 TEST_F(BrowserIOSurfaceManagerTest, UnregisterIOSurfaceSucceeds) {
 119   const int kIOSurfaceId = 1;
 120   const int kClientId = 1;
 121
 122   IOSurfaceManagerToken gpu_process_token = GetGpuProcessToken();
 123
 124   RegisterIOSurface(kIOSurfaceId, kClientId, 0);
 125
 126   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 127   request.io_surface_id = kIOSurfaceId;
 128   request.client_id = kClientId;
 129   memcpy(request.token_name, gpu_process_token.name,
 130          sizeof(gpu_process_token.name));
 131   EXPECT_TRUE(HandleUnregisterIOSurfaceRequest(request));
 132 }
 133
 134 TEST_F(BrowserIOSurfaceManagerTest, UnregisterIOSurfaceFailsWithInvalidToken) {
 135   const int kIOSurfaceId = 1;
 136   const int kClientId = 1;
 137
 138   RegisterIOSurface(kIOSurfaceId, kClientId, 0);
 139
 140   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 141   request.io_surface_id = kIOSurfaceId;
 142   request.client_id = kClientId;
 143   // Fails as request doesn't contain valid GPU token.
 144   EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
 145 }
 146
 147 TEST_F(BrowserIOSurfaceManagerTest,
 148        UnregisterIOSurfaceFailsWithChildProcessToken) {
 149   const int kIOSurfaceId = 1;
 150   const int kClientId = 1;
 151
 152   IOSurfaceManagerToken child_process_token =
 153       GenerateChildProcessToken(kClientId);
 154
 155   RegisterIOSurface(kIOSurfaceId, kClientId, 0);
 156
 157   IOSurfaceManagerHostMsg_UnregisterIOSurface request = {{0}};
 158   request.io_surface_id = kIOSurfaceId;
 159   request.client_id = kClientId;
 160   memcpy(request.token_name, child_process_token.name,
 161          sizeof(child_process_token.name));
 162   // Fails as child process is not allowed to unregister IOSurfaces.
 163   EXPECT_FALSE(HandleUnregisterIOSurfaceRequest(request));
 164 }
 165
 166 TEST_F(BrowserIOSurfaceManagerTest, AcquireIOSurfaceSucceeds) {
 167   const int kIOSurfaceId = 10;
 168   const int kClientId = 1;
 169   const mach_port_t kIOSurfacePortId = 100u;
 170
 171   IOSurfaceManagerToken child_process_token =
 172       GenerateChildProcessToken(kClientId);
 173
 174   RegisterIOSurface(kIOSurfaceId, kClientId, kIOSurfacePortId);
 175
 176   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 177   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 178   request.io_surface_id = kIOSurfaceId;
 179   memcpy(request.token_name, child_process_token.name,
 180          sizeof(child_process_token.name));
 181   EXPECT_TRUE(HandleAcquireIOSurfaceRequest(request, &reply));
 182   EXPECT_EQ(kIOSurfacePortId, reply.io_surface_port.name);
 183 }
 184
 185 TEST_F(BrowserIOSurfaceManagerTest, AcquireIOSurfaceFailsWithInvalidToken) {
 186   const int kIOSurfaceId = 10;
 187   const int kClientId = 1;
 188   const mach_port_t kIOSurfacePortId = 100u;
 189
 190   RegisterIOSurface(kIOSurfaceId, kClientId, kIOSurfacePortId);
 191
 192   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 193   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 194   request.io_surface_id = kIOSurfaceId;
 195   // Fails as request doesn't contain valid token.
 196   EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
 197 }
 198
 199 TEST_F(BrowserIOSurfaceManagerTest,
 200        AcquireIOSurfaceFailsWithWrongChildProcessToken) {
 201   const int kIOSurfaceId = 10;
 202   const int kClientId1 = 1;
 203   const int kClientId2 = 2;
 204   const mach_port_t kIOSurfacePortId = 100u;
 205
 206   IOSurfaceManagerToken child_process_token2 =
 207       GenerateChildProcessToken(kClientId2);
 208
 209   RegisterIOSurface(kIOSurfaceId, kClientId1, kIOSurfacePortId);
 210
 211   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 212   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 213   request.io_surface_id = kIOSurfaceId;
 214   memcpy(request.token_name, child_process_token2.name,
 215          sizeof(child_process_token2.name));
 216   // Fails as child process 2 is not allowed to acquire this IOSurface.
 217   EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
 218 }
 219
 220 TEST_F(BrowserIOSurfaceManagerTest,
 221        AcquireIOSurfaceFailsAfterInvalidatingChildProcessToken) {
 222   const int kIOSurfaceId = 10;
 223   const int kClientId = 1;
 224   const mach_port_t kIOSurfacePortId = 100u;
 225
 226   IOSurfaceManagerToken child_process_token =
 227       GenerateChildProcessToken(kClientId);
 228
 229   RegisterIOSurface(kIOSurfaceId, kClientId, kIOSurfacePortId);
 230
 231   InvalidateChildProcessToken(child_process_token);
 232
 233   IOSurfaceManagerHostMsg_AcquireIOSurface request = {{0}};
 234   IOSurfaceManagerMsg_AcquireIOSurfaceReply reply = {{0}};
 235   request.io_surface_id = kIOSurfaceId;
 236   memcpy(request.token_name, child_process_token.name,
 237          sizeof(child_process_token.name));
 238   // Fails as token is no longer valid.
 239   EXPECT_FALSE(HandleAcquireIOSurfaceRequest(request, &reply));
 240 }
 241
 242 }  // namespace content