src/native_client_sdk/src/tests/nacl_io_test/fake_resource_manager.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 "fake_resource_manager.h"
   6 #include "gtest/gtest.h"
   7 #include "sdk_util/auto_lock.h"
   8
   9 FakeResourceManager::FakeResourceManager() : next_handle_(1) {}
  10
  11 FakeResourceManager::~FakeResourceManager() {
  12   // The ref counts for all resources should be zero.
  13   for (ResourceMap::iterator iter = resource_map_.begin();
  14        iter != resource_map_.end();
  15        ++iter) {
  16     const FakeResourceTracker* resource_tracker = iter->second;
  17     EXPECT_EQ(0, resource_tracker->ref_count()) << "Leaked resource "
  18                                                 << resource_tracker->classname()
  19                                                 << "(" << iter->first
  20                                                 << "), created at "
  21                                                 << resource_tracker->file()
  22                                                 << ":"
  23                                                 << resource_tracker->line();
  24   }
  25 }
  26
  27 PP_Resource FakeResourceManager::Create(FakeResource* resource,
  28                                         const char* classname,
  29                                         const char* file,
  30                                         int line) {
  31   AUTO_LOCK(lock_);
  32   PP_Resource handle = next_handle_++;
  33   FakeResourceTracker* resource_tracker =
  34       new FakeResourceTracker(resource, classname, file, line);
  35   std::pair<ResourceMap::iterator, bool> result =
  36       resource_map_.insert(ResourceMap::value_type(handle, resource_tracker));
  37   EXPECT_TRUE(result.second);
  38   result.first->second->AddRef();
  39   return handle;
  40 }
  41
  42 void FakeResourceManager::AddRef(PP_Resource handle) {
  43   AUTO_LOCK(lock_);
  44   ResourceMap::iterator iter = resource_map_.find(handle);
  45   ASSERT_NE(resource_map_.end(), iter) << "AddRefing unknown resource "
  46                                        << handle;
  47
  48   FakeResourceTracker* resource_tracker = iter->second;
  49   EXPECT_LT(0, resource_tracker->ref_count()) << "AddRefing freed resource "
  50                                               << resource_tracker->classname()
  51                                               << "(" << handle
  52                                               << "), created at "
  53                                               << resource_tracker->file() << ":"
  54                                               << resource_tracker->line();
  55   resource_tracker->AddRef();
  56 }
  57
  58 void FakeResourceManager::Release(PP_Resource handle) {
  59   AUTO_LOCK(lock_);
  60   ResourceMap::iterator iter = resource_map_.find(handle);
  61   ASSERT_NE(resource_map_.end(), iter) << "Releasing unknown resource "
  62                                        << handle;
  63
  64   FakeResourceTracker* resource_tracker = iter->second;
  65   EXPECT_LT(0, resource_tracker->ref_count()) << "Releasing freed resource "
  66                                               << resource_tracker->classname()
  67                                               << "(" << handle
  68                                               << "), created at "
  69                                               << resource_tracker->file() << ":"
  70                                               << resource_tracker->line();
  71   resource_tracker->Release();
  72 }
  73
  74 FakeResourceTracker* FakeResourceManager::Get(PP_Resource handle) {
  75   AUTO_LOCK(lock_);
  76   ResourceMap::iterator iter = resource_map_.find(handle);
  77   if (iter == resource_map_.end()) {
  78     // Can't use FAIL() because it tries to return void.
  79     EXPECT_TRUE(false) << "Trying to get resource " << handle
  80                        << " that doesn't exist!";
  81     return NULL;
  82   }
  83
  84   FakeResourceTracker* resource_tracker = iter->second;
  85   EXPECT_LT(0, resource_tracker->ref_count()) << "Accessing freed resource "
  86                                               << resource_tracker->classname()
  87                                               << "(" << handle
  88                                               << "), created at "
  89                                               << resource_tracker->file() << ":"
  90                                               << resource_tracker->line();
  91
  92   return iter->second;
  93 }
  94
  95 FakeResourceTracker::FakeResourceTracker(FakeResource* resource,
  96                                          const char* classname,
  97                                          const char* file,
  98                                          int line)
  99     : resource_(resource),
 100       classname_(classname),
 101       file_(file),
 102       line_(line),
 103       ref_count_(0) {}
 104
 105 FakeResourceTracker::~FakeResourceTracker() { delete resource_; }
 106
 107 bool FakeResourceTracker::CheckType(const char* other_classname) const {
 108   if (strcmp(other_classname, classname_) != 0) {
 109     // Repeat the expectation, just to print out a nice error message before we
 110     // crash. :)
 111     EXPECT_STREQ(classname_, other_classname);
 112     return false;
 113   }
 114
 115   return true;
 116 }