content/browser/gpu/shader_disk_cache.cc

   1 // Copyright (c) 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 "content/browser/gpu/shader_disk_cache.h"
   6
   7 #include "base/threading/thread_checker.h"
   8 #include "content/browser/gpu/gpu_process_host.h"
   9 #include "content/public/browser/browser_thread.h"
  10 #include "gpu/command_buffer/common/constants.h"
  11 #include "net/base/cache_type.h"
  12 #include "net/base/io_buffer.h"
  13 #include "net/base/net_errors.h"
  14
  15 namespace content {
  16
  17 namespace {
  18
  19 static const base::FilePath::CharType kGpuCachePath[] =
  20     FILE_PATH_LITERAL("GPUCache");
  21
  22 void EntryCloser(disk_cache::Entry* entry) {
  23   entry->Close();
  24 }
  25
  26 void FreeDiskCacheIterator(scoped_ptr<disk_cache::Backend::Iterator> iterator) {
  27 }
  28
  29 }  // namespace
  30
  31 // ShaderDiskCacheEntry handles the work of caching/updating the cached
  32 // shaders.
  33 class ShaderDiskCacheEntry
  34     : public base::ThreadChecker,
  35       public base::RefCounted<ShaderDiskCacheEntry> {
  36  public:
  37   ShaderDiskCacheEntry(base::WeakPtr<ShaderDiskCache> cache,
  38                        const std::string& key,
  39                        const std::string& shader);
  40   void Cache();
  41
  42  private:
  43   friend class base::RefCounted<ShaderDiskCacheEntry>;
  44
  45   enum OpType {
  46     TERMINATE,
  47     OPEN_ENTRY,
  48     WRITE_DATA,
  49     CREATE_ENTRY,
  50   };
  51
  52   ~ShaderDiskCacheEntry();
  53
  54   void OnOpComplete(int rv);
  55
  56   int OpenCallback(int rv);
  57   int WriteCallback(int rv);
  58   int IOComplete(int rv);
  59
  60   base::WeakPtr<ShaderDiskCache> cache_;
  61   OpType op_type_;
  62   std::string key_;
  63   std::string shader_;
  64   disk_cache::Entry* entry_;
  65
  66   DISALLOW_COPY_AND_ASSIGN(ShaderDiskCacheEntry);
  67 };
  68
  69 // ShaderDiskReadHelper is used to load all of the cached shaders from the
  70 // disk cache and send to the memory cache.
  71 class ShaderDiskReadHelper
  72     : public base::ThreadChecker,
  73       public base::RefCounted<ShaderDiskReadHelper> {
  74  public:
  75   ShaderDiskReadHelper(base::WeakPtr<ShaderDiskCache> cache, int host_id);
  76   void LoadCache();
  77
  78  private:
  79   friend class base::RefCounted<ShaderDiskReadHelper>;
  80
  81   enum OpType {
  82     TERMINATE,
  83     OPEN_NEXT,
  84     OPEN_NEXT_COMPLETE,
  85     READ_COMPLETE,
  86     ITERATION_FINISHED
  87   };
  88
  89
  90   ~ShaderDiskReadHelper();
  91
  92   void OnOpComplete(int rv);
  93
  94   int OpenNextEntry();
  95   int OpenNextEntryComplete(int rv);
  96   int ReadComplete(int rv);
  97   int IterationComplete(int rv);
  98
  99   base::WeakPtr<ShaderDiskCache> cache_;
 100   OpType op_type_;
 101   scoped_ptr<disk_cache::Backend::Iterator> iter_;
 102   scoped_refptr<net::IOBufferWithSize> buf_;
 103   int host_id_;
 104   disk_cache::Entry* entry_;
 105
 106   DISALLOW_COPY_AND_ASSIGN(ShaderDiskReadHelper);
 107 };
 108
 109 class ShaderClearHelper
 110     : public base::RefCounted<ShaderClearHelper>,
 111       public base::SupportsWeakPtr<ShaderClearHelper> {
 112  public:
 113   ShaderClearHelper(scoped_refptr<ShaderDiskCache> cache,
 114                     const base::FilePath& path,
 115                     const base::Time& delete_begin,
 116                     const base::Time& delete_end,
 117                     const base::Closure& callback);
 118   void Clear();
 119
 120  private:
 121   friend class base::RefCounted<ShaderClearHelper>;
 122
 123   enum OpType {
 124     TERMINATE,
 125     VERIFY_CACHE_SETUP,
 126     DELETE_CACHE
 127   };
 128
 129   ~ShaderClearHelper();
 130
 131   void DoClearShaderCache(int rv);
 132
 133   scoped_refptr<ShaderDiskCache> cache_;
 134   OpType op_type_;
 135   base::FilePath path_;
 136   base::Time delete_begin_;
 137   base::Time delete_end_;
 138   base::Closure callback_;
 139
 140   DISALLOW_COPY_AND_ASSIGN(ShaderClearHelper);
 141 };
 142
 143 ShaderDiskCacheEntry::ShaderDiskCacheEntry(base::WeakPtr<ShaderDiskCache> cache,
 144                                            const std::string& key,
 145                                            const std::string& shader)
 146   : cache_(cache),
 147     op_type_(OPEN_ENTRY),
 148     key_(key),
 149     shader_(shader),
 150     entry_(NULL) {
 151 }
 152
 153 ShaderDiskCacheEntry::~ShaderDiskCacheEntry() {
 154   if (entry_)
 155     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
 156                             base::Bind(&EntryCloser, entry_));
 157 }
 158
 159 void ShaderDiskCacheEntry::Cache() {
 160   DCHECK(CalledOnValidThread());
 161   if (!cache_.get())
 162     return;
 163
 164   int rv = cache_->backend()->OpenEntry(
 165       key_,
 166       &entry_,
 167       base::Bind(&ShaderDiskCacheEntry::OnOpComplete, this));
 168   if (rv != net::ERR_IO_PENDING)
 169     OnOpComplete(rv);
 170 }
 171
 172 void ShaderDiskCacheEntry::OnOpComplete(int rv) {
 173   DCHECK(CalledOnValidThread());
 174   if (!cache_.get())
 175     return;
 176
 177   do {
 178     switch (op_type_) {
 179       case OPEN_ENTRY:
 180         rv = OpenCallback(rv);
 181         break;
 182       case CREATE_ENTRY:
 183         rv = WriteCallback(rv);
 184         break;
 185       case WRITE_DATA:
 186         rv = IOComplete(rv);
 187         break;
 188       case TERMINATE:
 189         rv = net::ERR_IO_PENDING;  // break the loop.
 190         break;
 191       default:
 192         NOTREACHED();  // Invalid op_type_ provided.
 193         break;
 194     }
 195   } while (rv != net::ERR_IO_PENDING);
 196 }
 197
 198 int ShaderDiskCacheEntry::OpenCallback(int rv) {
 199   DCHECK(CalledOnValidThread());
 200   // Called through OnOpComplete, so we know |cache_| is valid.
 201   if (rv == net::OK) {
 202     cache_->backend()->OnExternalCacheHit(key_);
 203     cache_->EntryComplete(this);
 204     op_type_ = TERMINATE;
 205     return rv;
 206   }
 207
 208   op_type_ = CREATE_ENTRY;
 209   return cache_->backend()->CreateEntry(
 210       key_,
 211       &entry_,
 212       base::Bind(&ShaderDiskCacheEntry::OnOpComplete, this));
 213 }
 214
 215 int ShaderDiskCacheEntry::WriteCallback(int rv) {
 216   DCHECK(CalledOnValidThread());
 217   // Called through OnOpComplete, so we know |cache_| is valid.
 218   if (rv != net::OK) {
 219     LOG(ERROR) << "Failed to create shader cache entry: " << rv;
 220     cache_->EntryComplete(this);
 221     op_type_ = TERMINATE;
 222     return rv;
 223   }
 224
 225   op_type_ = WRITE_DATA;
 226   scoped_refptr<net::StringIOBuffer> io_buf = new net::StringIOBuffer(shader_);
 227   return entry_->WriteData(
 228       1,
 229       0,
 230       io_buf.get(),
 231       shader_.length(),
 232       base::Bind(&ShaderDiskCacheEntry::OnOpComplete, this),
 233       false);
 234 }
 235
 236 int ShaderDiskCacheEntry::IOComplete(int rv) {
 237   DCHECK(CalledOnValidThread());
 238   // Called through OnOpComplete, so we know |cache_| is valid.
 239   cache_->EntryComplete(this);
 240   op_type_ = TERMINATE;
 241   return rv;
 242 }
 243
 244 ShaderDiskReadHelper::ShaderDiskReadHelper(
 245     base::WeakPtr<ShaderDiskCache> cache,
 246     int host_id)
 247     : cache_(cache),
 248       op_type_(OPEN_NEXT),
 249       buf_(NULL),
 250       host_id_(host_id),
 251       entry_(NULL) {
 252 }
 253
 254 void ShaderDiskReadHelper::LoadCache() {
 255   DCHECK(CalledOnValidThread());
 256   if (!cache_.get())
 257     return;
 258   OnOpComplete(net::OK);
 259 }
 260
 261 void ShaderDiskReadHelper::OnOpComplete(int rv) {
 262   DCHECK(CalledOnValidThread());
 263   if (!cache_.get())
 264     return;
 265
 266   do {
 267     switch (op_type_) {
 268       case OPEN_NEXT:
 269         rv = OpenNextEntry();
 270         break;
 271       case OPEN_NEXT_COMPLETE:
 272         rv = OpenNextEntryComplete(rv);
 273         break;
 274       case READ_COMPLETE:
 275         rv = ReadComplete(rv);
 276         break;
 277       case ITERATION_FINISHED:
 278         rv = IterationComplete(rv);
 279         break;
 280       case TERMINATE:
 281         cache_->ReadComplete();
 282         rv = net::ERR_IO_PENDING;  // break the loop
 283         break;
 284       default:
 285         NOTREACHED();  // Invalid state for read helper
 286         rv = net::ERR_FAILED;
 287         break;
 288     }
 289   } while (rv != net::ERR_IO_PENDING);
 290 }
 291
 292 int ShaderDiskReadHelper::OpenNextEntry() {
 293   DCHECK(CalledOnValidThread());
 294   // Called through OnOpComplete, so we know |cache_| is valid.
 295   op_type_ = OPEN_NEXT_COMPLETE;
 296   if (!iter_)
 297     iter_ = cache_->backend()->CreateIterator();
 298   return iter_->OpenNextEntry(
 299       &entry_, base::Bind(&ShaderDiskReadHelper::OnOpComplete, this));
 300 }
 301
 302 int ShaderDiskReadHelper::OpenNextEntryComplete(int rv) {
 303   DCHECK(CalledOnValidThread());
 304   // Called through OnOpComplete, so we know |cache_| is valid.
 305   if (rv == net::ERR_FAILED) {
 306     iter_.reset();
 307     op_type_ = ITERATION_FINISHED;
 308     return net::OK;
 309   }
 310
 311   if (rv < 0)
 312     return rv;
 313
 314   op_type_ = READ_COMPLETE;
 315   buf_ = new net::IOBufferWithSize(entry_->GetDataSize(1));
 316   return entry_->ReadData(
 317       1,
 318       0,
 319       buf_.get(),
 320       buf_->size(),
 321       base::Bind(&ShaderDiskReadHelper::OnOpComplete, this));
 322 }
 323
 324 int ShaderDiskReadHelper::ReadComplete(int rv) {
 325   DCHECK(CalledOnValidThread());
 326   // Called through OnOpComplete, so we know |cache_| is valid.
 327   if (rv && rv == buf_->size()) {
 328     GpuProcessHost* host = GpuProcessHost::FromID(host_id_);
 329     if (host)
 330       host->LoadedShader(entry_->GetKey(), std::string(buf_->data(),
 331                                                        buf_->size()));
 332   }
 333
 334   buf_ = NULL;
 335   entry_->Close();
 336   entry_ = NULL;
 337
 338   op_type_ = OPEN_NEXT;
 339   return net::OK;
 340 }
 341
 342 int ShaderDiskReadHelper::IterationComplete(int rv) {
 343   DCHECK(CalledOnValidThread());
 344   // Called through OnOpComplete, so we know |cache_| is valid.
 345   iter_.reset();
 346   op_type_ = TERMINATE;
 347   return net::OK;
 348 }
 349
 350 ShaderDiskReadHelper::~ShaderDiskReadHelper() {
 351   if (entry_) {
 352     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
 353                             base::Bind(&EntryCloser, entry_));
 354   }
 355   if (iter_) {
 356     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
 357                             base::Bind(&FreeDiskCacheIterator,
 358                                        base::Passed(&iter_)));
 359   }
 360 }
 361
 362 ShaderClearHelper::ShaderClearHelper(scoped_refptr<ShaderDiskCache> cache,
 363                     const base::FilePath& path,
 364                     const base::Time& delete_begin,
 365                     const base::Time& delete_end,
 366                     const base::Closure& callback)
 367     : cache_(cache),
 368       op_type_(VERIFY_CACHE_SETUP),
 369       path_(path),
 370       delete_begin_(delete_begin),
 371       delete_end_(delete_end),
 372       callback_(callback) {
 373 }
 374
 375 ShaderClearHelper::~ShaderClearHelper() {
 376   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 377 }
 378
 379 void ShaderClearHelper::Clear() {
 380   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 381   DoClearShaderCache(net::OK);
 382 }
 383
 384 void ShaderClearHelper::DoClearShaderCache(int rv) {
 385   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 386
 387   // Hold a ref to ourselves so when we do the CacheCleared call we don't get
 388   // auto-deleted when our ref count drops to zero.
 389   scoped_refptr<ShaderClearHelper> helper = this;
 390
 391   while (rv != net::ERR_IO_PENDING) {
 392     switch (op_type_) {
 393       case VERIFY_CACHE_SETUP:
 394         rv = cache_->SetAvailableCallback(
 395             base::Bind(&ShaderClearHelper::DoClearShaderCache, AsWeakPtr()));
 396         op_type_ = DELETE_CACHE;
 397         break;
 398       case DELETE_CACHE:
 399         rv = cache_->Clear(
 400             delete_begin_, delete_end_,
 401             base::Bind(&ShaderClearHelper::DoClearShaderCache, AsWeakPtr()));
 402         op_type_ = TERMINATE;
 403         break;
 404       case TERMINATE:
 405         ShaderCacheFactory::GetInstance()->CacheCleared(path_);
 406         callback_.Run();
 407         rv = net::ERR_IO_PENDING;  // Break the loop.
 408         break;
 409       default:
 410         NOTREACHED();  // Invalid state provided.
 411         op_type_ = TERMINATE;
 412         break;
 413     }
 414   }
 415 }
 416
 417 // static
 418 ShaderCacheFactory* ShaderCacheFactory::GetInstance() {
 419   return Singleton<ShaderCacheFactory,
 420       LeakySingletonTraits<ShaderCacheFactory> >::get();
 421 }
 422
 423 ShaderCacheFactory::ShaderCacheFactory() {
 424 }
 425
 426 ShaderCacheFactory::~ShaderCacheFactory() {
 427 }
 428
 429 void ShaderCacheFactory::SetCacheInfo(int32 client_id,
 430                                       const base::FilePath& path) {
 431   client_id_to_path_map_[client_id] = path;
 432 }
 433
 434 void ShaderCacheFactory::RemoveCacheInfo(int32 client_id) {
 435   client_id_to_path_map_.erase(client_id);
 436 }
 437
 438 scoped_refptr<ShaderDiskCache> ShaderCacheFactory::Get(int32 client_id) {
 439   ClientIdToPathMap::iterator iter =
 440       client_id_to_path_map_.find(client_id);
 441   if (iter == client_id_to_path_map_.end())
 442     return NULL;
 443   return ShaderCacheFactory::GetByPath(iter->second);
 444 }
 445
 446 scoped_refptr<ShaderDiskCache> ShaderCacheFactory::GetByPath(
 447     const base::FilePath& path) {
 448   ShaderCacheMap::iterator iter = shader_cache_map_.find(path);
 449   if (iter != shader_cache_map_.end())
 450     return iter->second;
 451
 452   ShaderDiskCache* cache = new ShaderDiskCache(path);
 453   cache->Init();
 454   return cache;
 455 }
 456
 457 void ShaderCacheFactory::AddToCache(const base::FilePath& key,
 458                                     ShaderDiskCache* cache) {
 459   shader_cache_map_[key] = cache;
 460 }
 461
 462 void ShaderCacheFactory::RemoveFromCache(const base::FilePath& key) {
 463   shader_cache_map_.erase(key);
 464 }
 465
 466 void ShaderCacheFactory::ClearByPath(const base::FilePath& path,
 467                                      const base::Time& delete_begin,
 468                                      const base::Time& delete_end,
 469                                      const base::Closure& callback) {
 470   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 471   DCHECK(!callback.is_null());
 472
 473   scoped_refptr<ShaderClearHelper> helper = new ShaderClearHelper(
 474       GetByPath(path), path, delete_begin, delete_end, callback);
 475
 476   // We could receive requests to clear the same path with different
 477   // begin/end times. So, we keep a list of requests. If we haven't seen this
 478   // path before we kick off the clear and add it to the list. If we have see it
 479   // already, then we already have a clear running. We add this clear to the
 480   // list and wait for any previous clears to finish.
 481   ShaderClearMap::iterator iter = shader_clear_map_.find(path);
 482   if (iter != shader_clear_map_.end()) {
 483     iter->second.push(helper);
 484     return;
 485   }
 486
 487   shader_clear_map_.insert(
 488       std::pair<base::FilePath, ShaderClearQueue>(path, ShaderClearQueue()));
 489   shader_clear_map_[path].push(helper);
 490   helper->Clear();
 491 }
 492
 493 void ShaderCacheFactory::CacheCleared(const base::FilePath& path) {
 494   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 495
 496   ShaderClearMap::iterator iter = shader_clear_map_.find(path);
 497   if (iter == shader_clear_map_.end()) {
 498     LOG(ERROR) << "Completed clear but missing clear helper.";
 499     return;
 500   }
 501
 502   iter->second.pop();
 503
 504   // If there are remaining items in the list we trigger the Clear on the
 505   // next one.
 506   if (!iter->second.empty()) {
 507     iter->second.front()->Clear();
 508     return;
 509   }
 510
 511   shader_clear_map_.erase(path);
 512 }
 513
 514 ShaderDiskCache::ShaderDiskCache(const base::FilePath& cache_path)
 515     : cache_available_(false),
 516       host_id_(0),
 517       cache_path_(cache_path),
 518       is_initialized_(false) {
 519   ShaderCacheFactory::GetInstance()->AddToCache(cache_path_, this);
 520 }
 521
 522 ShaderDiskCache::~ShaderDiskCache() {
 523   ShaderCacheFactory::GetInstance()->RemoveFromCache(cache_path_);
 524 }
 525
 526 void ShaderDiskCache::Init() {
 527   if (is_initialized_) {
 528     NOTREACHED();  // can't initialize disk cache twice.
 529     return;
 530   }
 531   is_initialized_ = true;
 532
 533   int rv = disk_cache::CreateCacheBackend(
 534       net::SHADER_CACHE,
 535       net::CACHE_BACKEND_DEFAULT,
 536       cache_path_.Append(kGpuCachePath),
 537       gpu::kDefaultMaxProgramCacheMemoryBytes,
 538       true,
 539       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
 540       NULL,
 541       &backend_,
 542       base::Bind(&ShaderDiskCache::CacheCreatedCallback, this));
 543
 544   if (rv == net::OK)
 545     cache_available_ = true;
 546 }
 547
 548 void ShaderDiskCache::Cache(const std::string& key, const std::string& shader) {
 549   if (!cache_available_)
 550     return;
 551
 552   scoped_refptr<ShaderDiskCacheEntry> shim =
 553       new ShaderDiskCacheEntry(AsWeakPtr(), key, shader);
 554   shim->Cache();
 555
 556   entry_map_[shim.get()] = shim;
 557 }
 558
 559 int ShaderDiskCache::Clear(
 560     const base::Time begin_time, const base::Time end_time,
 561     const net::CompletionCallback& completion_callback) {
 562   int rv;
 563   if (begin_time.is_null()) {
 564     rv = backend_->DoomAllEntries(completion_callback);
 565   } else {
 566     rv = backend_->DoomEntriesBetween(begin_time, end_time,
 567                                       completion_callback);
 568   }
 569   return rv;
 570 }
 571
 572 int32 ShaderDiskCache::Size() {
 573   if (!cache_available_)
 574     return -1;
 575   return backend_->GetEntryCount();
 576 }
 577
 578 int ShaderDiskCache::SetAvailableCallback(
 579     const net::CompletionCallback& callback) {
 580   if (cache_available_)
 581     return net::OK;
 582   available_callback_ = callback;
 583   return net::ERR_IO_PENDING;
 584 }
 585
 586 void ShaderDiskCache::CacheCreatedCallback(int rv) {
 587   if (rv != net::OK) {
 588     LOG(ERROR) << "Shader Cache Creation failed: " << rv;
 589     return;
 590   }
 591   helper_ = new ShaderDiskReadHelper(AsWeakPtr(), host_id_);
 592   helper_->LoadCache();
 593 }
 594
 595 void ShaderDiskCache::EntryComplete(void* entry) {
 596   entry_map_.erase(entry);
 597
 598   if (entry_map_.empty() && !cache_complete_callback_.is_null())
 599     cache_complete_callback_.Run(net::OK);
 600 }
 601
 602 void ShaderDiskCache::ReadComplete() {
 603   helper_ = NULL;
 604
 605   // The cache is considered available after we have finished reading any
 606   // of the old cache values off disk. This prevents a potential race where we
 607   // are reading from disk and execute a cache clear at the same time.
 608   cache_available_ = true;
 609   if (!available_callback_.is_null()) {
 610     available_callback_.Run(net::OK);
 611     available_callback_.Reset();
 612   }
 613 }
 614
 615 int ShaderDiskCache::SetCacheCompleteCallback(
 616     const net::CompletionCallback& callback) {
 617   if (entry_map_.empty()) {
 618     return net::OK;
 619   }
 620   cache_complete_callback_ = callback;
 621   return net::ERR_IO_PENDING;
 622 }
 623
 624 }  // namespace content
 625