| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "media/blink/url_index.h" |
| |
| #include <set> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/feature_list.h" |
| #include "base/location.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/single_thread_task_runner.h" |
| #include "base/threading/thread_task_runner_handle.h" |
| #include "base/time/time.h" |
| #include "media/base/media_switches.h" |
| #include "media/blink/resource_multibuffer_data_provider.h" |
| |
| namespace media { |
| |
| const int kBlockSizeShift = 15; // 1<<15 == 32kb |
| const int kUrlMappingTimeoutSeconds = 300; |
| |
| ResourceMultiBuffer::ResourceMultiBuffer(UrlData* url_data, int block_shift) |
| : MultiBuffer(block_shift, url_data->url_index_->lru_), |
| url_data_(url_data) {} |
| |
| ResourceMultiBuffer::~ResourceMultiBuffer() = default; |
| |
| std::unique_ptr<MultiBuffer::DataProvider> ResourceMultiBuffer::CreateWriter( |
| const MultiBufferBlockId& pos, |
| bool is_client_audio_element) { |
| auto writer = std::make_unique<ResourceMultiBufferDataProvider>( |
| url_data_, pos, is_client_audio_element); |
| writer->Start(); |
| return writer; |
| } |
| |
| bool ResourceMultiBuffer::RangeSupported() const { |
| return url_data_->range_supported_; |
| } |
| |
| void ResourceMultiBuffer::OnEmpty() { |
| url_data_->OnEmpty(); |
| } |
| |
| UrlData::UrlData(const GURL& url, CorsMode cors_mode, UrlIndex* url_index) |
| : url_(url), |
| have_data_origin_(false), |
| cors_mode_(cors_mode), |
| has_access_control_(false), |
| url_index_(url_index), |
| length_(kPositionNotSpecified), |
| range_supported_(false), |
| cacheable_(false), |
| last_used_(), |
| multibuffer_(this, url_index_->block_shift_) {} |
| |
| UrlData::~UrlData() { |
| UMA_HISTOGRAM_MEMORY_KB("Media.BytesReadFromCache", |
| BytesReadFromCache() >> 10); |
| UMA_HISTOGRAM_MEMORY_KB("Media.BytesReadFromNetwork", |
| BytesReadFromNetwork() >> 10); |
| } |
| |
| std::pair<GURL, UrlData::CorsMode> UrlData::key() const { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| return std::make_pair(url(), cors_mode()); |
| } |
| |
| void UrlData::set_valid_until(base::Time valid_until) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| valid_until_ = valid_until; |
| } |
| |
| void UrlData::MergeFrom(const scoped_refptr<UrlData>& other) { |
| // We're merging from another UrlData that refers to the *same* |
| // resource, so when we merge the metadata, we can use the most |
| // optimistic values. |
| if (ValidateDataOrigin(other->data_origin_)) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| valid_until_ = std::max(valid_until_, other->valid_until_); |
| // set_length() will not override the length if already known. |
| set_length(other->length_); |
| cacheable_ |= other->cacheable_; |
| range_supported_ |= other->range_supported_; |
| if (last_modified_.is_null()) { |
| last_modified_ = other->last_modified_; |
| } |
| bytes_read_from_cache_ += other->bytes_read_from_cache_; |
| // is_cors_corss_origin_ will not relax from true to false. |
| set_is_cors_cross_origin(other->is_cors_cross_origin_); |
| has_access_control_ |= other->has_access_control_; |
| multibuffer()->MergeFrom(other->multibuffer()); |
| } |
| } |
| |
| void UrlData::set_cacheable(bool cacheable) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| cacheable_ = cacheable; |
| } |
| |
| void UrlData::set_length(int64_t length) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (length != kPositionNotSpecified) { |
| length_ = length; |
| } |
| } |
| |
| void UrlData::set_is_cors_cross_origin(bool is_cors_cross_origin) { |
| if (is_cors_cross_origin_) |
| return; |
| is_cors_cross_origin_ = is_cors_cross_origin; |
| } |
| |
| void UrlData::set_has_access_control() { |
| has_access_control_ = true; |
| } |
| |
| void UrlData::RedirectTo(const scoped_refptr<UrlData>& url_data) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| // Copy any cached data over to the new location. |
| url_data->multibuffer()->MergeFrom(multibuffer()); |
| |
| // All |bytes_received_callbacks_| should also listen for bytes on the |
| // redirect UrlData. |
| for (const auto& cb : bytes_received_callbacks_) { |
| url_data->AddBytesReceivedCallback(cb); |
| } |
| |
| std::vector<RedirectCB> redirect_callbacks; |
| redirect_callbacks.swap(redirect_callbacks_); |
| for (const RedirectCB& cb : redirect_callbacks) { |
| cb.Run(url_data); |
| } |
| } |
| |
| void UrlData::Fail() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| // Handled similar to a redirect. |
| std::vector<RedirectCB> redirect_callbacks; |
| redirect_callbacks.swap(redirect_callbacks_); |
| for (const RedirectCB& cb : redirect_callbacks) { |
| cb.Run(nullptr); |
| } |
| } |
| |
| void UrlData::OnRedirect(const RedirectCB& cb) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| redirect_callbacks_.push_back(cb); |
| } |
| |
| void UrlData::Use() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| last_used_ = base::Time::Now(); |
| } |
| |
| bool UrlData::ValidateDataOrigin(const GURL& origin) { |
| if (!have_data_origin_) { |
| data_origin_ = origin; |
| have_data_origin_ = true; |
| return true; |
| } |
| if (cors_mode_ == UrlData::CORS_UNSPECIFIED) { |
| return data_origin_ == origin; |
| } |
| // The actual cors checks is done in the net layer. |
| return true; |
| } |
| |
| void UrlData::OnEmpty() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| url_index_->RemoveUrlData(this); |
| } |
| |
| bool UrlData::FullyCached() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| if (length_ == kPositionNotSpecified) |
| return false; |
| // Check that the first unavailable block in the cache is after the |
| // end of the file. |
| return (multibuffer()->FindNextUnavailable(0) << kBlockSizeShift) >= length_; |
| } |
| |
| bool UrlData::Valid() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| base::Time now = base::Time::Now(); |
| if (!range_supported_ && !FullyCached()) |
| return false; |
| // When ranges are not supported, we cannot re-use cached data. |
| if (valid_until_ > now) |
| return true; |
| if (now - last_used_ < |
| base::TimeDelta::FromSeconds(kUrlMappingTimeoutSeconds)) |
| return true; |
| return false; |
| } |
| |
| void UrlData::set_last_modified(base::Time last_modified) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| last_modified_ = last_modified; |
| } |
| |
| void UrlData::set_etag(const std::string& etag) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| etag_ = etag; |
| } |
| |
| void UrlData::set_range_supported() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| range_supported_ = true; |
| } |
| |
| ResourceMultiBuffer* UrlData::multibuffer() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| return &multibuffer_; |
| } |
| |
| void UrlData::AddBytesReceivedCallback(BytesReceivedCB bytes_received_cb) { |
| bytes_received_callbacks_.emplace_back(std::move(bytes_received_cb)); |
| } |
| |
| void UrlData::AddBytesReadFromNetwork(int64_t b) { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| bytes_read_from_network_ += b; |
| for (const auto& cb : bytes_received_callbacks_) { |
| cb.Run(b); |
| } |
| } |
| |
| size_t UrlData::CachedSize() { |
| DCHECK(thread_checker_.CalledOnValidThread()); |
| return multibuffer()->map().size(); |
| } |
| |
| UrlIndex::UrlIndex(ResourceFetchContext* fetch_context) |
| : UrlIndex(fetch_context, kBlockSizeShift) {} |
| |
| UrlIndex::UrlIndex(ResourceFetchContext* fetch_context, int block_shift) |
| : fetch_context_(fetch_context), |
| lru_(new MultiBuffer::GlobalLRU(base::ThreadTaskRunnerHandle::Get())), |
| block_shift_(block_shift), |
| memory_pressure_listener_( |
| base::Bind(&UrlIndex::OnMemoryPressure, base::Unretained(this))) {} |
| |
| UrlIndex::~UrlIndex() { |
| #if DCHECK_IS_ON() |
| // Verify that only |this| holds reference to UrlData instances. |
| auto dcheck_has_one_ref = [](const UrlDataMap::value_type& entry) { |
| DCHECK(entry.second->HasOneRef()); |
| }; |
| std::for_each(indexed_data_.begin(), indexed_data_.end(), dcheck_has_one_ref); |
| #endif |
| } |
| |
| void UrlIndex::RemoveUrlData(const scoped_refptr<UrlData>& url_data) { |
| DCHECK(url_data->multibuffer()->map().empty()); |
| |
| auto i = indexed_data_.find(url_data->key()); |
| if (i != indexed_data_.end() && i->second == url_data) |
| indexed_data_.erase(i); |
| } |
| |
| scoped_refptr<UrlData> UrlIndex::GetByUrl(const GURL& gurl, |
| UrlData::CorsMode cors_mode) { |
| auto i = indexed_data_.find(std::make_pair(gurl, cors_mode)); |
| if (i != indexed_data_.end() && i->second->Valid()) { |
| return i->second; |
| } |
| |
| return NewUrlData(gurl, cors_mode); |
| } |
| |
| scoped_refptr<UrlData> UrlIndex::NewUrlData(const GURL& url, |
| UrlData::CorsMode cors_mode) { |
| return new UrlData(url, cors_mode, this); |
| } |
| |
| void UrlIndex::OnMemoryPressure( |
| base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level) { |
| switch (memory_pressure_level) { |
| case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_NONE: |
| break; |
| case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_MODERATE: |
| lru_->TryFree(128); // try to free 128 32kb blocks if possible |
| break; |
| case base::MemoryPressureListener::MEMORY_PRESSURE_LEVEL_CRITICAL: |
| lru_->TryFreeAll(); // try to free as many blocks as possible |
| break; |
| } |
| } |
| |
| namespace { |
| bool IsStrongEtag(const std::string& etag) { |
| return etag.size() > 2 && etag[0] == '"'; |
| } |
| |
| bool IsNewDataForSameResource(const scoped_refptr<UrlData>& new_entry, |
| const scoped_refptr<UrlData>& old_entry) { |
| if (IsStrongEtag(new_entry->etag()) && IsStrongEtag(old_entry->etag())) { |
| if (new_entry->etag() != old_entry->etag()) |
| return true; |
| } |
| if (!new_entry->last_modified().is_null()) { |
| if (new_entry->last_modified() != old_entry->last_modified()) |
| return true; |
| } |
| return false; |
| } |
| } // namespace |
| |
| scoped_refptr<UrlData> UrlIndex::TryInsert( |
| const scoped_refptr<UrlData>& url_data) { |
| auto iter = indexed_data_.find(url_data->key()); |
| if (iter == indexed_data_.end()) { |
| // If valid and not already indexed, index it. |
| if (url_data->Valid()) { |
| indexed_data_.insert(iter, std::make_pair(url_data->key(), url_data)); |
| } |
| return url_data; |
| } |
| |
| // A UrlData instance for the same key is already indexed. |
| |
| // If the indexed instance is the same as |url_data|, |
| // nothing needs to be done. |
| if (iter->second == url_data) |
| return url_data; |
| |
| // The indexed instance is different. |
| // Check if it should be replaced with |url_data|. |
| if (IsNewDataForSameResource(url_data, iter->second)) { |
| if (url_data->Valid()) { |
| iter->second = url_data; |
| } |
| return url_data; |
| } |
| |
| if (url_data->Valid()) { |
| if ((!iter->second->Valid() || |
| url_data->CachedSize() > iter->second->CachedSize())) { |
| iter->second = url_data; |
| } else { |
| iter->second->MergeFrom(url_data); |
| } |
| } |
| return iter->second; |
| } |
| |
| } // namespace media |