1 // Copyright 2013 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 "components/nacl/browser/pnacl_host.h" 6 7 #include <stdio.h> 8 #include "base/bind.h" 9 #include "base/files/scoped_temp_dir.h" 10 #include "base/run_loop.h" 11 #include "base/threading/sequenced_worker_pool.h" 12 #include "components/nacl/browser/pnacl_translation_cache.h" 13 #include "content/public/browser/browser_thread.h" 14 #include "content/public/test/test_browser_thread_bundle.h" 15 #include "net/base/test_completion_callback.h" 16 #include "testing/gtest/include/gtest/gtest.h" 17 18 #if defined(OS_WIN) 19 #define snprintf _snprintf 20 #endif 21 22 namespace pnacl { 23 24 class PnaclHostTest : public testing::Test { 25 protected: 26 PnaclHostTest() 27 : host_(NULL), 28 temp_callback_count_(0), 29 write_callback_count_(0), 30 thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {} 31 virtual void SetUp() { 32 host_ = new PnaclHost(); 33 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 34 host_->InitForTest(temp_dir_.path(), true); 35 base::RunLoop().RunUntilIdle(); 36 EXPECT_EQ(PnaclHost::CacheReady, host_->cache_state_); 37 } 38 virtual void TearDown() { 39 EXPECT_EQ(0U, host_->pending_translations()); 40 // Give the host a chance to de-init the backend, and then delete it. 41 host_->RendererClosing(0); 42 FlushQueues(); 43 EXPECT_EQ(PnaclHost::CacheUninitialized, host_->cache_state_); 44 delete host_; 45 } 46 // Flush the blocking pool first, then any tasks it posted to the IO thread. 47 // Do 2 rounds of flushing, because some operations require 2 trips back and 48 // forth between the threads. 49 void FlushQueues() { 50 content::BrowserThread::GetBlockingPool()->FlushForTesting(); 51 base::RunLoop().RunUntilIdle(); 52 content::BrowserThread::GetBlockingPool()->FlushForTesting(); 53 base::RunLoop().RunUntilIdle(); 54 } 55 int GetCacheSize() { return host_->disk_cache_->Size(); } 56 int CacheIsInitialized() { 57 return host_->cache_state_ == PnaclHost::CacheReady; 58 } 59 void ReInitBackend() { 60 host_->InitForTest(temp_dir_.path(), true); 61 base::RunLoop().RunUntilIdle(); 62 EXPECT_EQ(PnaclHost::CacheReady, host_->cache_state_); 63 } 64 65 public: // Required for derived classes to bind this method 66 // Callbacks used by tests which call GetNexeFd. 67 // CallbackExpectMiss checks that the fd is valid and a miss is reported, 68 // and also writes some data into the file, which is read back by 69 // CallbackExpectHit 70 void CallbackExpectMiss(const base::File& file, bool is_hit) { 71 EXPECT_FALSE(is_hit); 72 ASSERT_TRUE(file.IsValid()); 73 base::File::Info info; 74 base::File* mutable_file = const_cast<base::File*>(&file); 75 EXPECT_TRUE(mutable_file->GetInfo(&info)); 76 EXPECT_FALSE(info.is_directory); 77 EXPECT_EQ(0LL, info.size); 78 char str[16]; 79 memset(str, 0x0, 16); 80 snprintf(str, 16, "testdata%d", ++write_callback_count_); 81 EXPECT_EQ(16, mutable_file->Write(0, str, 16)); 82 temp_callback_count_++; 83 } 84 void CallbackExpectHit(const base::File& file, bool is_hit) { 85 EXPECT_TRUE(is_hit); 86 ASSERT_TRUE(file.IsValid()); 87 base::File::Info info; 88 base::File* mutable_file = const_cast<base::File*>(&file); 89 EXPECT_TRUE(mutable_file->GetInfo(&info)); 90 EXPECT_FALSE(info.is_directory); 91 EXPECT_EQ(16LL, info.size); 92 char data[16]; 93 memset(data, 0x0, 16); 94 char str[16]; 95 memset(str, 0x0, 16); 96 snprintf(str, 16, "testdata%d", write_callback_count_); 97 EXPECT_EQ(16, mutable_file->Read(0, data, 16)); 98 EXPECT_STREQ(str, data); 99 temp_callback_count_++; 100 } 101 102 protected: 103 PnaclHost* host_; 104 int temp_callback_count_; 105 int write_callback_count_; 106 content::TestBrowserThreadBundle thread_bundle_; 107 base::ScopedTempDir temp_dir_; 108 }; 109 110 static nacl::PnaclCacheInfo GetTestCacheInfo() { 111 nacl::PnaclCacheInfo info; 112 info.pexe_url = GURL("http://www.google.com"); 113 info.abi_version = 0; 114 info.opt_level = 0; 115 info.has_no_store_header = false; 116 return info; 117 } 118 119 #define GET_NEXE_FD(renderer, instance, incognito, info, expect_hit) \ 120 do { \ 121 SCOPED_TRACE(""); \ 122 host_->GetNexeFd( \ 123 renderer, \ 124 0, /* ignore render_view_id for now */ \ 125 instance, \ 126 incognito, \ 127 info, \ 128 base::Bind(expect_hit ? &PnaclHostTest::CallbackExpectHit \ 129 : &PnaclHostTest::CallbackExpectMiss, \ 130 base::Unretained(this))); \ 131 } while (0) 132 133 TEST_F(PnaclHostTest, BasicMiss) { 134 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 135 // Test cold miss. 136 GET_NEXE_FD(0, 0, false, info, false); 137 EXPECT_EQ(1U, host_->pending_translations()); 138 FlushQueues(); 139 EXPECT_EQ(1U, host_->pending_translations()); 140 EXPECT_EQ(1, temp_callback_count_); 141 host_->TranslationFinished(0, 0, true); 142 FlushQueues(); 143 EXPECT_EQ(0U, host_->pending_translations()); 144 // Test that a different cache info field also misses. 145 info.etag = std::string("something else"); 146 GET_NEXE_FD(0, 0, false, info, false); 147 FlushQueues(); 148 EXPECT_EQ(2, temp_callback_count_); 149 EXPECT_EQ(1U, host_->pending_translations()); 150 host_->RendererClosing(0); 151 FlushQueues(); 152 // Check that the cache has de-initialized after the last renderer goes away. 153 EXPECT_FALSE(CacheIsInitialized()); 154 } 155 156 TEST_F(PnaclHostTest, BadArguments) { 157 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 158 GET_NEXE_FD(0, 0, false, info, false); 159 EXPECT_EQ(1U, host_->pending_translations()); 160 host_->TranslationFinished(0, 1, true); // nonexistent translation 161 EXPECT_EQ(1U, host_->pending_translations()); 162 host_->RendererClosing(1); // nonexistent renderer 163 EXPECT_EQ(1U, host_->pending_translations()); 164 FlushQueues(); 165 EXPECT_EQ(1, temp_callback_count_); 166 host_->RendererClosing(0); // close without finishing 167 } 168 169 TEST_F(PnaclHostTest, BasicHit) { 170 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 171 GET_NEXE_FD(0, 0, false, info, false); 172 FlushQueues(); 173 EXPECT_EQ(1, temp_callback_count_); 174 host_->TranslationFinished(0, 0, true); 175 FlushQueues(); 176 GET_NEXE_FD(0, 1, false, info, true); 177 FlushQueues(); 178 EXPECT_EQ(2, temp_callback_count_); 179 EXPECT_EQ(0U, host_->pending_translations()); 180 } 181 182 TEST_F(PnaclHostTest, TranslationErrors) { 183 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 184 GET_NEXE_FD(0, 0, false, info, false); 185 // Early abort, before temp file request returns 186 host_->TranslationFinished(0, 0, false); 187 FlushQueues(); 188 EXPECT_EQ(0U, host_->pending_translations()); 189 EXPECT_EQ(0, temp_callback_count_); 190 // The backend will have been freed when the query comes back and there 191 // are no pending translations. 192 EXPECT_FALSE(CacheIsInitialized()); 193 ReInitBackend(); 194 // Check that another request for the same info misses successfully. 195 GET_NEXE_FD(0, 0, false, info, false); 196 FlushQueues(); 197 host_->TranslationFinished(0, 0, true); 198 FlushQueues(); 199 EXPECT_EQ(1, temp_callback_count_); 200 EXPECT_EQ(0U, host_->pending_translations()); 201 202 // Now try sending the error after the temp file request returns 203 info.abi_version = 222; 204 GET_NEXE_FD(0, 0, false, info, false); 205 FlushQueues(); 206 EXPECT_EQ(2, temp_callback_count_); 207 host_->TranslationFinished(0, 0, false); 208 FlushQueues(); 209 EXPECT_EQ(0U, host_->pending_translations()); 210 // Check another successful miss 211 GET_NEXE_FD(0, 0, false, info, false); 212 FlushQueues(); 213 EXPECT_EQ(3, temp_callback_count_); 214 host_->TranslationFinished(0, 0, false); 215 EXPECT_EQ(0U, host_->pending_translations()); 216 } 217 218 TEST_F(PnaclHostTest, OverlappedMissesAfterTempReturn) { 219 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 220 GET_NEXE_FD(0, 0, false, info, false); 221 FlushQueues(); 222 EXPECT_EQ(1, temp_callback_count_); 223 EXPECT_EQ(1U, host_->pending_translations()); 224 // Test that a second request for the same nexe while the first one is still 225 // outstanding eventually hits. 226 GET_NEXE_FD(0, 1, false, info, true); 227 FlushQueues(); 228 EXPECT_EQ(2U, host_->pending_translations()); 229 // The temp file should not be returned to the second request until after the 230 // first is finished translating. 231 EXPECT_EQ(1, temp_callback_count_); 232 host_->TranslationFinished(0, 0, true); 233 FlushQueues(); 234 EXPECT_EQ(2, temp_callback_count_); 235 EXPECT_EQ(0U, host_->pending_translations()); 236 } 237 238 TEST_F(PnaclHostTest, OverlappedMissesBeforeTempReturn) { 239 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 240 GET_NEXE_FD(0, 0, false, info, false); 241 // Send the 2nd fd request before the first one returns a temp file. 242 GET_NEXE_FD(0, 1, false, info, true); 243 FlushQueues(); 244 EXPECT_EQ(1, temp_callback_count_); 245 EXPECT_EQ(2U, host_->pending_translations()); 246 FlushQueues(); 247 EXPECT_EQ(2U, host_->pending_translations()); 248 EXPECT_EQ(1, temp_callback_count_); 249 host_->TranslationFinished(0, 0, true); 250 FlushQueues(); 251 EXPECT_EQ(2, temp_callback_count_); 252 EXPECT_EQ(0U, host_->pending_translations()); 253 } 254 255 TEST_F(PnaclHostTest, OverlappedHitsBeforeTempReturn) { 256 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 257 // Store one in the cache and complete it. 258 GET_NEXE_FD(0, 0, false, info, false); 259 FlushQueues(); 260 EXPECT_EQ(1, temp_callback_count_); 261 host_->TranslationFinished(0, 0, true); 262 FlushQueues(); 263 EXPECT_EQ(0U, host_->pending_translations()); 264 GET_NEXE_FD(0, 0, false, info, true); 265 // Request the second before the first temp file returns. 266 GET_NEXE_FD(0, 1, false, info, true); 267 FlushQueues(); 268 EXPECT_EQ(3, temp_callback_count_); 269 EXPECT_EQ(0U, host_->pending_translations()); 270 } 271 272 TEST_F(PnaclHostTest, OverlappedHitsAfterTempReturn) { 273 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 274 // Store one in the cache and complete it. 275 GET_NEXE_FD(0, 0, false, info, false); 276 FlushQueues(); 277 EXPECT_EQ(1, temp_callback_count_); 278 host_->TranslationFinished(0, 0, true); 279 FlushQueues(); 280 EXPECT_EQ(0U, host_->pending_translations()); 281 GET_NEXE_FD(0, 0, false, info, true); 282 FlushQueues(); 283 GET_NEXE_FD(0, 1, false, info, true); 284 FlushQueues(); 285 EXPECT_EQ(3, temp_callback_count_); 286 EXPECT_EQ(0U, host_->pending_translations()); 287 } 288 289 TEST_F(PnaclHostTest, OverlappedMissesRendererClosing) { 290 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 291 GET_NEXE_FD(0, 0, false, info, false); 292 // Send the 2nd fd request from a different renderer. 293 // Test that it eventually gets an fd after the first renderer closes. 294 GET_NEXE_FD(1, 1, false, info, false); 295 FlushQueues(); 296 EXPECT_EQ(1, temp_callback_count_); 297 EXPECT_EQ(2U, host_->pending_translations()); 298 FlushQueues(); 299 EXPECT_EQ(2U, host_->pending_translations()); 300 EXPECT_EQ(1, temp_callback_count_); 301 host_->RendererClosing(0); 302 FlushQueues(); 303 EXPECT_EQ(2, temp_callback_count_); 304 EXPECT_EQ(1U, host_->pending_translations()); 305 host_->RendererClosing(1); 306 } 307 308 TEST_F(PnaclHostTest, Incognito) { 309 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 310 GET_NEXE_FD(0, 0, true, info, false); 311 FlushQueues(); 312 EXPECT_EQ(1, temp_callback_count_); 313 host_->TranslationFinished(0, 0, true); 314 FlushQueues(); 315 // Check that an incognito translation is not stored in the cache 316 GET_NEXE_FD(0, 0, false, info, false); 317 FlushQueues(); 318 EXPECT_EQ(2, temp_callback_count_); 319 host_->TranslationFinished(0, 0, true); 320 FlushQueues(); 321 // Check that an incognito translation can hit from a normal one. 322 GET_NEXE_FD(0, 0, true, info, true); 323 FlushQueues(); 324 EXPECT_EQ(3, temp_callback_count_); 325 } 326 327 TEST_F(PnaclHostTest, IncognitoOverlappedMiss) { 328 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 329 GET_NEXE_FD(0, 0, true, info, false); 330 GET_NEXE_FD(0, 1, false, info, false); 331 FlushQueues(); 332 // Check that both translations have returned misses, (i.e. that the 333 // second one has not blocked on the incognito one) 334 EXPECT_EQ(2, temp_callback_count_); 335 host_->TranslationFinished(0, 0, true); 336 host_->TranslationFinished(0, 1, true); 337 FlushQueues(); 338 EXPECT_EQ(0U, host_->pending_translations()); 339 340 // Same test, but issue the 2nd request after the first has returned a miss. 341 info.abi_version = 222; 342 GET_NEXE_FD(0, 0, true, info, false); 343 FlushQueues(); 344 EXPECT_EQ(3, temp_callback_count_); 345 GET_NEXE_FD(0, 1, false, info, false); 346 FlushQueues(); 347 EXPECT_EQ(4, temp_callback_count_); 348 host_->RendererClosing(0); 349 } 350 351 TEST_F(PnaclHostTest, IncognitoSecondOverlappedMiss) { 352 // If the non-incognito request comes first, it should 353 // behave exactly like OverlappedMissBeforeTempReturn 354 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 355 GET_NEXE_FD(0, 0, false, info, false); 356 // Send the 2nd fd request before the first one returns a temp file. 357 GET_NEXE_FD(0, 1, true, info, true); 358 FlushQueues(); 359 EXPECT_EQ(1, temp_callback_count_); 360 EXPECT_EQ(2U, host_->pending_translations()); 361 FlushQueues(); 362 EXPECT_EQ(2U, host_->pending_translations()); 363 EXPECT_EQ(1, temp_callback_count_); 364 host_->TranslationFinished(0, 0, true); 365 FlushQueues(); 366 EXPECT_EQ(2, temp_callback_count_); 367 EXPECT_EQ(0U, host_->pending_translations()); 368 } 369 370 // Test that pexes with the no-store header do not get cached. 371 TEST_F(PnaclHostTest, CacheControlNoStore) { 372 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 373 info.has_no_store_header = true; 374 GET_NEXE_FD(0, 0, false, info, false); 375 FlushQueues(); 376 EXPECT_EQ(1, temp_callback_count_); 377 host_->TranslationFinished(0, 0, true); 378 FlushQueues(); 379 EXPECT_EQ(0U, host_->pending_translations()); 380 EXPECT_EQ(0, GetCacheSize()); 381 } 382 383 // Test that no-store pexes do not wait, but do duplicate translations 384 TEST_F(PnaclHostTest, NoStoreOverlappedMiss) { 385 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 386 info.has_no_store_header = true; 387 GET_NEXE_FD(0, 0, false, info, false); 388 GET_NEXE_FD(0, 1, false, info, false); 389 FlushQueues(); 390 // Check that both translations have returned misses, (i.e. that the 391 // second one has not blocked on the first one) 392 EXPECT_EQ(2, temp_callback_count_); 393 host_->TranslationFinished(0, 0, true); 394 host_->TranslationFinished(0, 1, true); 395 FlushQueues(); 396 EXPECT_EQ(0U, host_->pending_translations()); 397 398 // Same test, but issue the 2nd request after the first has returned a miss. 399 info.abi_version = 222; 400 GET_NEXE_FD(0, 0, false, info, false); 401 FlushQueues(); 402 EXPECT_EQ(3, temp_callback_count_); 403 GET_NEXE_FD(0, 1, false, info, false); 404 FlushQueues(); 405 EXPECT_EQ(4, temp_callback_count_); 406 host_->RendererClosing(0); 407 } 408 409 TEST_F(PnaclHostTest, ClearTranslationCache) { 410 nacl::PnaclCacheInfo info = GetTestCacheInfo(); 411 // Add 2 entries in the cache 412 GET_NEXE_FD(0, 0, false, info, false); 413 info.abi_version = 222; 414 GET_NEXE_FD(0, 1, false, info, false); 415 FlushQueues(); 416 EXPECT_EQ(2, temp_callback_count_); 417 host_->TranslationFinished(0, 0, true); 418 host_->TranslationFinished(0, 1, true); 419 FlushQueues(); 420 EXPECT_EQ(0U, host_->pending_translations()); 421 EXPECT_EQ(2, GetCacheSize()); 422 net::TestCompletionCallback cb; 423 // Since we are using a memory backend, the clear should happen immediately. 424 host_->ClearTranslationCacheEntriesBetween( 425 base::Time(), base::Time(), base::Bind(cb.callback(), 0)); 426 // Check that the translation cache has been cleared before flushing the 427 // queues, because the backend will be freed once it is. 428 EXPECT_EQ(0, GetCacheSize()); 429 EXPECT_EQ(0, cb.GetResult(net::ERR_IO_PENDING)); 430 // Now check that the backend has been freed. 431 EXPECT_FALSE(CacheIsInitialized()); 432 } 433 434 // A version of PnaclHostTest that initializes cache on disk. 435 class PnaclHostTestDisk : public PnaclHostTest { 436 protected: 437 virtual void SetUp() { 438 host_ = new PnaclHost(); 439 ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); 440 host_->InitForTest(temp_dir_.path(), false); 441 EXPECT_EQ(PnaclHost::CacheInitializing, host_->cache_state_); 442 } 443 void DeInit() { 444 host_->DeInitIfSafe(); 445 } 446 }; 447 TEST_F(PnaclHostTestDisk, DeInitWhileInitializing) { 448 // Since there's no easy way to pump message queues one message at a time, we 449 // have to simulate what would happen if 1 DeInitIfsafe task gets queued, then 450 // a GetNexeFd gets queued, and then another DeInitIfSafe gets queued before 451 // the first one runs. We can just shortcut and call DeInitIfSafe while the 452 // cache is still initializing. 453 DeInit(); 454 base::RunLoop().RunUntilIdle(); 455 } 456 457 } // namespace pnacl 458
