id stringlengths 15 19 | content stringlengths 62 138k |
|---|---|
primevul_data_101 | static std::string WrapWithTD(std::string text) {
return "<td>" + text + "</td>";
}
The vulnerability label is: Non-vulnerable |
primevul_data_102 | static std::string WrapWithTH(std::string text) {
return "<th>" + text + "</th>";
}
The vulnerability label is: Non-vulnerable |
primevul_data_103 | virtual const Network* active_network() const {
if (ethernet_ && ethernet_->is_active())
return ethernet_;
if (wifi_ && wifi_->is_active())
return wifi_;
if (cellular_ && cellular_->is_active())
return cellular_;
return NULL;
}
The vulnerability label is: Non-vulnerable |
primevul_data_104 | virtual const Network* active_network() const { return NULL; }
The vulnerability label is: Non-vulnerable |
primevul_data_105 | virtual bool cellular_available() const {
return available_devices_ & (1 << TYPE_CELLULAR);
}
The vulnerability label is: Non-vulnerable |
primevul_data_106 | virtual bool cellular_available() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_107 | virtual bool cellular_connected() const {
return cellular_ ? cellular_->connected() : false;
}
The vulnerability label is: Non-vulnerable |
primevul_data_108 | virtual bool cellular_connected() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_109 | virtual bool cellular_connecting() const {
return cellular_ ? cellular_->connecting() : false;
}
The vulnerability label is: Non-vulnerable |
primevul_data_110 | virtual bool cellular_connecting() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_111 | virtual bool cellular_enabled() const {
return enabled_devices_ & (1 << TYPE_CELLULAR);
}
The vulnerability label is: Non-vulnerable |
primevul_data_112 | virtual CellularNetwork* cellular_network() { return cellular_; }
The vulnerability label is: Non-vulnerable |
primevul_data_113 | virtual const CellularNetworkVector& cellular_networks() const {
return cellular_networks_;
}
The vulnerability label is: Non-vulnerable |
primevul_data_114 | CellularNetwork::DataLeft CellularNetwork::data_left() const {
if (data_plans_.empty())
return DATA_NORMAL;
const CellularDataPlan& plan(data_plans_[0]);
if (plan.plan_type == CELLULAR_DATA_PLAN_UNLIMITED) {
base::TimeDelta remaining = plan.plan_end_time - plan.update_time;
if (remaining <= base::Time... |
primevul_data_115 | virtual bool ethernet_available() const { return true; }
The vulnerability label is: Non-vulnerable |
primevul_data_116 | virtual bool ethernet_connected() const {
return ethernet_ ? ethernet_->connected() : false;
}
The vulnerability label is: Non-vulnerable |
primevul_data_117 | virtual bool ethernet_connected() const { return true; }
The vulnerability label is: Non-vulnerable |
primevul_data_118 | virtual bool ethernet_connecting() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_119 | virtual bool ethernet_enabled() const {
return enabled_devices_ & (1 << TYPE_ETHERNET);
}
The vulnerability label is: Non-vulnerable |
primevul_data_120 | virtual bool ethernet_enabled() const { return true; }
The vulnerability label is: Non-vulnerable |
primevul_data_121 | virtual EthernetNetwork* ethernet_network() { return ethernet_; }
The vulnerability label is: Non-vulnerable |
primevul_data_122 | virtual bool has_cellular_networks() const {
return cellular_networks_.begin() != cellular_networks_.end();
}
The vulnerability label is: Non-vulnerable |
primevul_data_123 | bool CellularNetwork::is_gsm() const {
return network_technology_ != NETWORK_TECHNOLOGY_EVDO &&
network_technology_ != NETWORK_TECHNOLOGY_1XRTT &&
network_technology_ != NETWORK_TECHNOLOGY_UNKNOWN;
}
The vulnerability label is: Non-vulnerable |
primevul_data_124 | virtual bool offline_mode() const { return offline_mode_; }
The vulnerability label is: Non-vulnerable |
primevul_data_125 | virtual bool offline_mode() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_126 | virtual const WifiNetworkVector& remembered_wifi_networks() const {
return remembered_wifi_networks_;
}
The vulnerability label is: Non-vulnerable |
primevul_data_127 | virtual const WifiNetworkVector& remembered_wifi_networks() const {
return wifi_networks_;
}
The vulnerability label is: Non-vulnerable |
primevul_data_128 | virtual bool wifi_available() const {
return available_devices_ & (1 << TYPE_WIFI);
}
The vulnerability label is: Non-vulnerable |
primevul_data_129 | virtual bool wifi_available() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_130 | virtual bool wifi_connected() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_131 | virtual bool wifi_connecting() const {
return wifi_ ? wifi_->connecting() : false;
}
The vulnerability label is: Non-vulnerable |
primevul_data_132 | virtual bool wifi_connecting() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_133 | virtual bool wifi_enabled() const {
return enabled_devices_ & (1 << TYPE_WIFI);
}
The vulnerability label is: Non-vulnerable |
primevul_data_134 | virtual bool wifi_enabled() const { return false; }
The vulnerability label is: Non-vulnerable |
primevul_data_135 | virtual WifiNetwork* wifi_network() { return wifi_; }
The vulnerability label is: Non-vulnerable |
primevul_data_136 | virtual const WifiNetworkVector& wifi_networks() const {
return wifi_networks_;
}
The vulnerability label is: Non-vulnerable |
primevul_data_137 | CellularNetwork::~CellularNetwork() {
}
The vulnerability label is: Non-vulnerable |
primevul_data_138 | ~NetworkLibraryImpl() {
network_manager_observers_.Clear();
if (network_manager_monitor_)
DisconnectPropertyChangeMonitor(network_manager_monitor_);
data_plan_observers_.Clear();
if (data_plan_monitor_)
DisconnectDataPlanUpdateMonitor(data_plan_monitor_);
STLDeleteValues(&network_obser... |
primevul_data_139 | ~NetworkLibraryStubImpl() { if (ethernet_) delete ethernet_; }
The vulnerability label is: Non-vulnerable |
primevul_data_140 | virtual ~NetworkObserverList() {
if (network_monitor_)
DisconnectPropertyChangeMonitor(network_monitor_);
}
The vulnerability label is: Non-vulnerable |
primevul_data_141 | bool AddCallback(GetUsageAndQuotaCallback* callback, bool unlimited) {
if (unlimited)
unlimited_callbacks_.push_back(callback);
else
callbacks_.push_back(callback);
return (callbacks_.size() + unlimited_callbacks_.size() == 1);
}
The vulnerability label is: Non-vulnerable |
primevul_data_142 | bool AppendEntry(const TableEntry& entry) {
entries_.push_back(entry);
return true;
}
The vulnerability label is: Non-vulnerable |
primevul_data_143 | void CallCallbacksAndClear(
CallbackList* callbacks, QuotaStatusCode status,
int64 usage, int64 quota) {
for (CallbackList::iterator iter = callbacks->begin();
iter != callbacks->end(); ++iter) {
(*iter)->Run(status, usage, quota);
delete *iter;
}
callbacks->clear();
}
... |
primevul_data_144 | void CheckCompleted() {
if (--waiting_callbacks_ <= 0) {
DispatchCallbacks();
DCHECK(callbacks_.empty());
DCHECK(unlimited_callbacks_.empty());
UsageAndQuotaDispatcherTaskMap& dispatcher_map =
manager()->usage_and_quota_dispatchers_;
DCHECK(dispatcher_map.find(std::make_pa... |
primevul_data_145 | void CountOriginType(const std::set<GURL>& origins,
SpecialStoragePolicy* policy,
size_t* protected_origins,
size_t* unlimited_origins) {
DCHECK(protected_origins);
DCHECK(unlimited_origins);
*protected_origins = 0;
*unlimited_origins = 0;
if (!po... |
primevul_data_146 | QuotaManager::UsageAndQuotaDispatcherTask::Create(
QuotaManager* manager, const std::string& host, StorageType type) {
switch (type) {
case kStorageTypeTemporary:
return new UsageAndQuotaDispatcherTaskForTemporary(
manager, host);
case kStorageTypePersistent:
return new UsageAndQuota... |
primevul_data_147 | void QuotaManager::DeleteOnCorrectThread() const {
if (!io_thread_->BelongsToCurrentThread()) {
io_thread_->DeleteSoon(FROM_HERE, this);
return;
}
delete this;
}
The vulnerability label is: Non-vulnerable |
primevul_data_148 | void QuotaManager::DeleteOriginData(
const GURL& origin, StorageType type, StatusCallback* callback) {
LazyInitialize();
if (origin.is_empty() || clients_.empty()) {
callback->Run(kQuotaStatusOk);
delete callback;
return;
}
OriginDataDeleter* deleter =
new OriginDataDeleter(this, origin,... |
primevul_data_149 | DeleteOriginInfo(
QuotaManager* manager,
const GURL& origin,
StorageType type)
: DatabaseTaskBase(manager),
origin_(origin),
type_(type) {}
The vulnerability label is: Non-vulnerable |
primevul_data_150 | void DidDeleteOriginData(QuotaStatusCode status) {
DCHECK_GT(remaining_clients_, 0);
if (status != kQuotaStatusOk)
++error_count_;
if (--remaining_clients_ == 0)
CallCompleted();
}
The vulnerability label is: Non-vulnerable |
primevul_data_151 | void QuotaManager::DidGetAvailableSpaceForEviction(
QuotaStatusCode status,
int64 available_space) {
eviction_context_.get_usage_and_quota_callback->Run(status,
eviction_context_.usage,
eviction_context_.unlimited_usage,
eviction_context_.quota, available_space);
eviction_context_.get_usag... |
primevul_data_152 | void QuotaManager::DidGetDatabaseLRUOrigin(const GURL& origin) {
if (origins_in_use_.find(origin) != origins_in_use_.end() ||
access_notified_origins_.find(origin) != access_notified_origins_.end())
lru_origin_callback_->Run(GURL());
else
lru_origin_callback_->Run(origin);
access_notified_origins_.c... |
primevul_data_153 | void DidGetGlobalQuota(QuotaStatusCode status,
StorageType type,
int64 quota) {
DCHECK_EQ(type_, type);
quota_status_ = status;
quota_ = quota;
CheckCompleted();
}
The vulnerability label is: Non-vulnerable |
primevul_data_154 | void QuotaManager::DidGetGlobalQuotaForEviction(
QuotaStatusCode status,
StorageType type,
int64 quota) {
DCHECK_EQ(type, kStorageTypeTemporary);
if (status != kQuotaStatusOk) {
eviction_context_.get_usage_and_quota_callback->Run(
status, 0, 0, 0, 0);
eviction_context_.get_usage_and_quot... |
primevul_data_155 | void DidGetGlobalUsage(StorageType type, int64 usage,
int64 unlimited_usage) {
DCHECK_EQ(type_, type);
DCHECK_GE(usage, unlimited_usage);
global_usage_ = usage;
global_unlimited_usage_ = unlimited_usage;
CheckCompleted();
}
The vulnerability label is: Non-vulnerable |
primevul_data_156 | void QuotaManager::DidGetGlobalUsageForEviction(
StorageType type, int64 usage, int64 unlimited_usage) {
DCHECK_EQ(type, kStorageTypeTemporary);
DCHECK_GE(usage, unlimited_usage);
eviction_context_.usage = usage;
eviction_context_.unlimited_usage = unlimited_usage;
GetTemporaryGlobalQuota(callback_factory... |
primevul_data_157 | void DidGetHostQuota(QuotaStatusCode status,
const std::string& host,
StorageType type,
int64 quota) {
DCHECK_EQ(host_, host);
DCHECK_EQ(type_, type);
quota_status_ = status;
quota_ = quota;
CheckCompleted();
}
The vulnerabil... |
primevul_data_158 | void DidGetHostUsage(const std::string& host,
StorageType type,
int64 usage) {
DCHECK_EQ(host_, host);
DCHECK_EQ(type_, type);
host_usage_ = usage;
CheckCompleted();
}
The vulnerability label is: Non-vulnerable |
primevul_data_159 | void QuotaManager::DidGetPersistentGlobalUsageForHistogram(
StorageType type,
int64 usage,
int64 unlimited_usage) {
UMA_HISTOGRAM_MBYTES("Quota.GlobalUsageOfPersistentStorage", usage);
std::set<GURL> origins;
GetCachedOrigins(type, &origins);
size_t num_origins = origins.size();
size_t protected... |
primevul_data_160 | void QuotaManager::DidInitializeTemporaryGlobalQuota(int64 quota) {
temporary_global_quota_ = quota;
temporary_global_quota_callbacks_.Run(
db_disabled_ ? kQuotaErrorInvalidAccess : kQuotaStatusOk,
kStorageTypeTemporary, quota);
if (db_disabled_ || eviction_disabled_)
return;
if (!need_initial... |
primevul_data_161 | void QuotaManager::DidRunInitialGetTemporaryGlobalUsage(
StorageType type, int64 usage_unused, int64 unlimited_usage_unused) {
DCHECK_EQ(type, kStorageTypeTemporary);
scoped_refptr<InitializeTemporaryOriginsInfoTask> task(
new InitializeTemporaryOriginsInfoTask(
this, temporary_usage_tracker_.ge... |
primevul_data_162 | void QuotaManager::DumpOriginInfoTable(
DumpOriginInfoTableCallback* callback) {
make_scoped_refptr(new DumpOriginInfoTableTask(this, callback))->Start();
}
The vulnerability label is: Non-vulnerable |
primevul_data_163 | DumpOriginInfoTableTask(
QuotaManager* manager,
Callback* callback)
: DatabaseTaskBase(manager),
callback_(callback) {
}
The vulnerability label is: Non-vulnerable |
primevul_data_164 | void QuotaManager::DumpQuotaTable(DumpQuotaTableCallback* callback) {
make_scoped_refptr(new DumpQuotaTableTask(this, callback))->Start();
}
The vulnerability label is: Non-vulnerable |
primevul_data_165 | DumpQuotaTableTask(
QuotaManager* manager,
Callback* callback)
: DatabaseTaskBase(manager),
callback_(callback) {
}
The vulnerability label is: Non-vulnerable |
primevul_data_166 | void QuotaManager::EvictOriginData(
const GURL& origin,
StorageType type,
EvictOriginDataCallback* callback) {
DCHECK(io_thread_->BelongsToCurrentThread());
DCHECK_EQ(type, kStorageTypeTemporary);
eviction_context_.evicted_origin = origin;
eviction_context_.evicted_type = type;
eviction_context_.... |
primevul_data_167 | void QuotaManager::GetAvailableSpace(AvailableSpaceCallback* callback) {
scoped_refptr<AvailableSpaceQueryTask> task(
new AvailableSpaceQueryTask(this, db_thread_, profile_path_, callback));
task->Start();
}
The vulnerability label is: Non-vulnerable |
primevul_data_168 | void QuotaManager::GetCachedOrigins(
StorageType type, std::set<GURL>* origins) {
DCHECK(origins);
LazyInitialize();
switch (type) {
case kStorageTypeTemporary:
DCHECK(temporary_usage_tracker_.get());
temporary_usage_tracker_->GetCachedOrigins(origins);
return;
case kStorageTypePersi... |
primevul_data_169 | void QuotaManager::GetGlobalUsage(
StorageType type,
GlobalUsageCallback* callback) {
LazyInitialize();
GetUsageTracker(type)->GetGlobalUsage(callback);
}
The vulnerability label is: Non-vulnerable |
primevul_data_170 | void QuotaManager::GetHostUsage(const std::string& host, StorageType type,
HostUsageCallback* callback) {
LazyInitialize();
GetUsageTracker(type)->GetHostUsage(host, callback);
}
The vulnerability label is: Non-vulnerable |
primevul_data_171 | int64 GetInitialTemporaryStorageQuotaSize(const FilePath& path,
bool is_incognito) {
int64 free_space = base::SysInfo::AmountOfFreeDiskSpace(path);
UMA_HISTOGRAM_MBYTES("Quota.FreeDiskSpaceForProfile", free_space);
if (free_space < QuotaManager::kTemporaryStorageQuotaDef... |
primevul_data_172 | void QuotaManager::GetLRUOrigin(
StorageType type,
GetLRUOriginCallback* callback) {
LazyInitialize();
DCHECK(!lru_origin_callback_.get());
lru_origin_callback_.reset(callback);
if (db_disabled_) {
lru_origin_callback_->Run(GURL());
lru_origin_callback_.reset();
return;
}
scoped_refptr<G... |
primevul_data_173 | GetLRUOriginTask(
QuotaManager* manager,
StorageType type,
const std::map<GURL, int>& origins_in_use,
const std::map<GURL, int>& origins_in_error,
GetLRUOriginCallback *callback)
: DatabaseTaskBase(manager),
type_(type),
callback_(callback),
special_storage_... |
primevul_data_174 | GetModifiedSinceTask(
QuotaManager* manager,
StorageType type,
base::Time modified_since,
GetOriginsCallback* callback)
: DatabaseTaskBase(manager),
type_(type),
modified_since_(modified_since),
callback_(callback) {}
The vulnerability label is: Non-vulnerable |
primevul_data_175 | void QuotaManager::GetOriginsModifiedSince(
StorageType type,
base::Time modified_since,
GetOriginsCallback* callback) {
LazyInitialize();
make_scoped_refptr(new GetModifiedSinceTask(
this, type, modified_since, callback))->Start();
}
The vulnerability label is: Non-vulnerable |
primevul_data_176 | GetPersistentHostQuotaTask(
QuotaManager* manager,
const std::string& host,
HostQuotaCallback* callback)
: DatabaseTaskBase(manager),
host_(host),
quota_(-1),
callback_(callback) {
}
The vulnerability label is: Non-vulnerable |
primevul_data_177 | void QuotaManager::GetStatistics(
std::map<std::string, std::string>* statistics) {
DCHECK(statistics);
if (temporary_storage_evictor_.get()) {
std::map<std::string, int64> stats;
temporary_storage_evictor_->GetStatistics(&stats);
for (std::map<std::string, int64>::iterator p = stats.begin();
... |
primevul_data_178 | void QuotaManager::GetTemporaryGlobalQuota(QuotaCallback* callback) {
LazyInitialize();
if (temporary_global_quota_ >= 0) {
callback->Run(kQuotaStatusOk,
kStorageTypeTemporary, temporary_global_quota_);
delete callback;
return;
}
temporary_global_quota_callbacks_.Add(callback);
}
... |
primevul_data_179 | void QuotaManager::GetUsageAndQuota(
const GURL& origin, StorageType type,
GetUsageAndQuotaCallback* callback_ptr) {
scoped_ptr<GetUsageAndQuotaCallback> callback(callback_ptr);
LazyInitialize();
if (type == kStorageTypeUnknown) {
callback->Run(kQuotaErrorNotSupported, 0, 0);
return;
}
st... |
primevul_data_180 | void QuotaManager::GetUsageAndQuotaForEviction(
GetUsageAndQuotaForEvictionCallback* callback) {
DCHECK(io_thread_->BelongsToCurrentThread());
DCHECK(!eviction_context_.get_usage_and_quota_callback.get());
eviction_context_.get_usage_and_quota_callback.reset(callback);
GetGlobalUsage(kStorageTypeTemporary,... |
primevul_data_181 | UsageTracker* QuotaManager::GetUsageTracker(StorageType type) const {
switch (type) {
case kStorageTypeTemporary:
return temporary_usage_tracker_.get();
case kStorageTypePersistent:
return persistent_usage_tracker_.get();
default:
NOTREACHED();
}
return NULL;
}
The vulnerability la... |
primevul_data_182 | InitializeTask(
QuotaManager* manager,
const FilePath& profile_path,
bool is_incognito)
: DatabaseTaskBase(manager),
profile_path_(profile_path),
is_incognito_(is_incognito),
need_initialize_origins_(false),
temporary_storage_quota_(-1) {
}
The vulnerability... |
primevul_data_183 | InitializeTemporaryOriginsInfoTask(
QuotaManager* manager,
UsageTracker* temporary_usage_tracker)
: DatabaseTaskBase(manager),
has_registered_origins_(false) {
DCHECK(temporary_usage_tracker);
temporary_usage_tracker->GetCachedOrigins(&origins_);
}
The vulnerability label is: Non... |
primevul_data_184 | void QuotaManager::LazyInitialize() {
DCHECK(io_thread_->BelongsToCurrentThread());
if (database_.get()) {
return;
}
database_.reset(new QuotaDatabase(is_incognito_ ? FilePath() :
profile_path_.AppendASCII(kDatabaseName)));
temporary_usage_tracker_.reset(
new UsageTracker(clients_, kStorageT... |
primevul_data_185 | QuotaCallback* NewWaitableGlobalQuotaCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetGlobalQuota);
}
The vulnerability label is: Non-vulnerable |
primevul_data_186 | GlobalUsageCallback* NewWaitableGlobalUsageCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetGlobalUsage);
}
The vulnerability label is: Non-vulnerable |
primevul_data_187 | HostQuotaCallback* NewWaitableHostQuotaCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetHostQuota);
}
The vulnerability label is: Non-vulnerable |
primevul_data_188 | HostUsageCallback* NewWaitableHostUsageCallback() {
++waiting_callbacks_;
return callback_factory_.NewCallback(
&UsageAndQuotaDispatcherTask::DidGetHostUsage);
}
The vulnerability label is: Non-vulnerable |
primevul_data_189 | void QuotaManager::NotifyOriginInUse(const GURL& origin) {
DCHECK(io_thread_->BelongsToCurrentThread());
origins_in_use_[origin]++;
}
The vulnerability label is: Non-vulnerable |
primevul_data_190 | void QuotaManagerProxy::NotifyOriginInUse(
const GURL& origin) {
if (!io_thread_->BelongsToCurrentThread()) {
io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
this, &QuotaManagerProxy::NotifyOriginInUse, origin));
return;
}
if (manager_)
manager_->NotifyOriginInUse(origin);
}
The vulne... |
primevul_data_191 | void QuotaManager::NotifyOriginNoLongerInUse(const GURL& origin) {
DCHECK(io_thread_->BelongsToCurrentThread());
DCHECK(IsOriginInUse(origin));
int& count = origins_in_use_[origin];
if (--count == 0)
origins_in_use_.erase(origin);
}
The vulnerability label is: Non-vulnerable |
primevul_data_192 | void QuotaManagerProxy::NotifyOriginNoLongerInUse(
const GURL& origin) {
if (!io_thread_->BelongsToCurrentThread()) {
io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
this, &QuotaManagerProxy::NotifyOriginNoLongerInUse, origin));
return;
}
if (manager_)
manager_->NotifyOriginNoLongerInUs... |
primevul_data_193 | void QuotaManager::NotifyStorageAccessed(
QuotaClient::ID client_id,
const GURL& origin, StorageType type) {
NotifyStorageAccessedInternal(client_id, origin, type, base::Time::Now());
}
The vulnerability label is: Non-vulnerable |
primevul_data_194 | void QuotaManagerProxy::NotifyStorageAccessed(
QuotaClient::ID client_id,
const GURL& origin,
StorageType type) {
if (!io_thread_->BelongsToCurrentThread()) {
io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
this, &QuotaManagerProxy::NotifyStorageAccessed,
client_id, origin, type));
... |
primevul_data_195 | void QuotaManager::NotifyStorageAccessedInternal(
QuotaClient::ID client_id,
const GURL& origin, StorageType type,
base::Time accessed_time) {
LazyInitialize();
if (type == kStorageTypeTemporary && lru_origin_callback_.get()) {
access_notified_origins_.insert(origin);
}
if (db_disabled_)
re... |
primevul_data_196 | void QuotaManager::NotifyStorageModified(
QuotaClient::ID client_id,
const GURL& origin, StorageType type, int64 delta) {
NotifyStorageModifiedInternal(client_id, origin, type, delta,
base::Time::Now());
}
The vulnerability label is: Non-vulnerable |
primevul_data_197 | void QuotaManagerProxy::NotifyStorageModified(
QuotaClient::ID client_id,
const GURL& origin,
StorageType type,
int64 delta) {
if (!io_thread_->BelongsToCurrentThread()) {
io_thread_->PostTask(FROM_HERE, NewRunnableMethod(
this, &QuotaManagerProxy::NotifyStorageModified,
client_id,... |
primevul_data_198 | void QuotaManager::NotifyStorageModifiedInternal(
QuotaClient::ID client_id,
const GURL& origin,
StorageType type,
int64 delta,
base::Time modified_time) {
LazyInitialize();
GetUsageTracker(type)->UpdateUsageCache(client_id, origin, delta);
make_scoped_refptr(new UpdateModifiedTimeTask(
... |
primevul_data_199 | OriginDataDeleter(QuotaManager* manager,
const GURL& origin,
StorageType type,
StatusCallback* callback)
: QuotaTask(manager),
origin_(origin),
type_(type),
error_count_(0),
remaining_clients_(-1),
callback_(call... |
primevul_data_200 | QuotaManager::QuotaManager(bool is_incognito,
const FilePath& profile_path,
base::MessageLoopProxy* io_thread,
base::MessageLoopProxy* db_thread,
SpecialStoragePolicy* special_storage_policy)
: is_incognito_(is... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.