| // 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 "extensions/browser/extension_api_frame_id_map.h" |
| |
| #include <tuple> |
| #include <utility> |
| |
| #include "base/bind.h" |
| #include "base/logging.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/task/post_task.h" |
| #include "content/public/browser/browser_task_traits.h" |
| #include "content/public/browser/browser_thread.h" |
| #include "content/public/browser/navigation_handle.h" |
| #include "content/public/browser/render_frame_host.h" |
| #include "content/public/browser/render_process_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/common/child_process_host.h" |
| #include "extensions/browser/extensions_browser_client.h" |
| #include "extensions/common/constants.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| // The map is accessed on the IO and UI thread, so construct it once and never |
| // delete it. |
| base::LazyInstance<ExtensionApiFrameIdMap>::Leaky g_map_instance = |
| LAZY_INSTANCE_INITIALIZER; |
| |
| bool IsFrameRoutingIdValid(int frame_routing_id) { |
| // frame_routing_id == -2 = MSG_ROUTING_NONE -> not a RenderFrameHost. |
| // frame_routing_id == -1 -> should be MSG_ROUTING_NONE, but there are |
| // callers that use "-1" for unknown frames. |
| return frame_routing_id > -1; |
| } |
| |
| } // namespace |
| |
| const int ExtensionApiFrameIdMap::kInvalidFrameId = -1; |
| const int ExtensionApiFrameIdMap::kTopFrameId = 0; |
| |
| ExtensionApiFrameIdMap::FrameData::FrameData() |
| : frame_id(kInvalidFrameId), |
| parent_frame_id(kInvalidFrameId), |
| tab_id(extension_misc::kUnknownTabId), |
| window_id(extension_misc::kUnknownWindowId) {} |
| |
| ExtensionApiFrameIdMap::FrameData::FrameData(int frame_id, |
| int parent_frame_id, |
| int tab_id, |
| int window_id, |
| GURL last_committed_main_frame_url) |
| : frame_id(frame_id), |
| parent_frame_id(parent_frame_id), |
| tab_id(tab_id), |
| window_id(window_id), |
| last_committed_main_frame_url(std::move(last_committed_main_frame_url)) {} |
| |
| ExtensionApiFrameIdMap::FrameData::~FrameData() = default; |
| |
| ExtensionApiFrameIdMap::FrameData::FrameData( |
| const ExtensionApiFrameIdMap::FrameData& other) = default; |
| ExtensionApiFrameIdMap::FrameData& ExtensionApiFrameIdMap::FrameData::operator=( |
| const ExtensionApiFrameIdMap::FrameData& other) = default; |
| |
| ExtensionApiFrameIdMap::RenderFrameIdKey::RenderFrameIdKey() |
| : render_process_id(content::ChildProcessHost::kInvalidUniqueID), |
| frame_routing_id(MSG_ROUTING_NONE) {} |
| |
| ExtensionApiFrameIdMap::RenderFrameIdKey::RenderFrameIdKey( |
| int render_process_id, |
| int frame_routing_id) |
| : render_process_id(render_process_id), |
| frame_routing_id(frame_routing_id) {} |
| |
| ExtensionApiFrameIdMap::FrameDataCallbacks::FrameDataCallbacks() |
| : is_iterating(false) {} |
| |
| ExtensionApiFrameIdMap::FrameDataCallbacks::FrameDataCallbacks( |
| const FrameDataCallbacks& other) = default; |
| |
| ExtensionApiFrameIdMap::FrameDataCallbacks::~FrameDataCallbacks() {} |
| |
| bool ExtensionApiFrameIdMap::RenderFrameIdKey::operator<( |
| const RenderFrameIdKey& other) const { |
| return std::tie(render_process_id, frame_routing_id) < |
| std::tie(other.render_process_id, other.frame_routing_id); |
| } |
| |
| bool ExtensionApiFrameIdMap::RenderFrameIdKey::operator==( |
| const RenderFrameIdKey& other) const { |
| return render_process_id == other.render_process_id && |
| frame_routing_id == other.frame_routing_id; |
| } |
| |
| ExtensionApiFrameIdMap::ExtensionApiFrameIdMap() { |
| // The browser client can be null in unittests. |
| if (ExtensionsBrowserClient::Get()) { |
| helper_ = |
| ExtensionsBrowserClient::Get()->CreateExtensionApiFrameIdMapHelper( |
| this); |
| } |
| } |
| |
| ExtensionApiFrameIdMap::~ExtensionApiFrameIdMap() {} |
| |
| // static |
| ExtensionApiFrameIdMap* ExtensionApiFrameIdMap::Get() { |
| return g_map_instance.Pointer(); |
| } |
| |
| // static |
| int ExtensionApiFrameIdMap::GetFrameId(content::RenderFrameHost* rfh) { |
| if (!rfh) |
| return kInvalidFrameId; |
| if (rfh->GetParent()) |
| return rfh->GetFrameTreeNodeId(); |
| return kTopFrameId; |
| } |
| |
| // static |
| int ExtensionApiFrameIdMap::GetFrameId( |
| content::NavigationHandle* navigation_handle) { |
| return navigation_handle->IsInMainFrame() |
| ? kTopFrameId |
| : navigation_handle->GetFrameTreeNodeId(); |
| } |
| |
| // static |
| int ExtensionApiFrameIdMap::GetParentFrameId(content::RenderFrameHost* rfh) { |
| return rfh ? GetFrameId(rfh->GetParent()) : kInvalidFrameId; |
| } |
| |
| // static |
| int ExtensionApiFrameIdMap::GetParentFrameId( |
| content::NavigationHandle* navigation_handle) { |
| if (navigation_handle->IsInMainFrame()) |
| return kInvalidFrameId; |
| |
| if (navigation_handle->IsParentMainFrame()) |
| return kTopFrameId; |
| |
| return navigation_handle->GetParentFrame()->GetFrameTreeNodeId(); |
| } |
| |
| // static |
| content::RenderFrameHost* ExtensionApiFrameIdMap::GetRenderFrameHostById( |
| content::WebContents* web_contents, |
| int frame_id) { |
| // Although it is technically possible to map |frame_id| to a RenderFrameHost |
| // without WebContents, we choose to not do that because in the extension API |
| // frameIds are only guaranteed to be meaningful in combination with a tabId. |
| if (!web_contents) |
| return nullptr; |
| |
| if (frame_id == kInvalidFrameId) |
| return nullptr; |
| |
| if (frame_id == kTopFrameId) |
| return web_contents->GetMainFrame(); |
| |
| DCHECK_GE(frame_id, 1); |
| |
| // Unfortunately, extension APIs do not know which process to expect for a |
| // given frame ID, so we must use an unsafe API here that could return a |
| // different RenderFrameHost than the caller may have expected (e.g., one that |
| // changed after a cross-process navigation). |
| return web_contents->UnsafeFindFrameByFrameTreeNodeId(frame_id); |
| } |
| |
| ExtensionApiFrameIdMap::FrameData ExtensionApiFrameIdMap::KeyToValue( |
| const RenderFrameIdKey& key) const { |
| content::RenderFrameHost* rfh = content::RenderFrameHost::FromID( |
| key.render_process_id, key.frame_routing_id); |
| |
| if (!rfh || !rfh->IsRenderFrameLive()) |
| return FrameData(); |
| |
| content::WebContents* web_contents = |
| content::WebContents::FromRenderFrameHost(rfh); |
| |
| // The RenderFrameHost may not have an associated WebContents in cases |
| // such as interstitial pages. |
| GURL last_committed_main_frame_url = |
| web_contents ? web_contents->GetLastCommittedURL() : GURL(); |
| int tab_id = extension_misc::kUnknownTabId; |
| int window_id = extension_misc::kUnknownWindowId; |
| if (helper_) |
| helper_->PopulateTabData(rfh, &tab_id, &window_id); |
| return FrameData(GetFrameId(rfh), GetParentFrameId(rfh), tab_id, window_id, |
| std::move(last_committed_main_frame_url)); |
| } |
| |
| ExtensionApiFrameIdMap::FrameData ExtensionApiFrameIdMap::LookupFrameDataOnUI( |
| const RenderFrameIdKey& key, |
| bool is_from_io) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| bool lookup_successful = false; |
| FrameData data; |
| FrameDataMap::const_iterator frame_id_iter = frame_data_map_.find(key); |
| if (frame_id_iter != frame_data_map_.end()) { |
| lookup_successful = true; |
| data = frame_id_iter->second; |
| } else { |
| data = KeyToValue(key); |
| // Don't save invalid values in the map. |
| if (data.frame_id != kInvalidFrameId) { |
| lookup_successful = true; |
| auto kvpair = FrameDataMap::value_type(key, data); |
| base::AutoLock lock(frame_data_map_lock_); |
| frame_data_map_.insert(kvpair); |
| } |
| } |
| |
| // TODO(devlin): Depending on how the data looks, this may be removable after |
| // a few cycles. Check back in M52 to see if it's still needed. |
| if (is_from_io) { |
| UMA_HISTOGRAM_BOOLEAN("Extensions.ExtensionFrameMapLookupSuccessful", |
| lookup_successful); |
| } |
| |
| return data; |
| } |
| |
| void ExtensionApiFrameIdMap::ReceivedFrameDataOnIO( |
| const RenderFrameIdKey& key, |
| const FrameData& cached_frame_data) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| auto map_iter = callbacks_map_.find(key); |
| if (map_iter == callbacks_map_.end()) { |
| // Can happen if ReceivedFrameDataOnIO was called after the frame ID was |
| // resolved (e.g. via GetFrameDataOnIO), but before PostTaskAndReply |
| // replied. |
| return; |
| } |
| |
| FrameDataCallbacks& callbacks = map_iter->second; |
| |
| if (callbacks.is_iterating) |
| return; |
| callbacks.is_iterating = true; |
| |
| // Note: Extra items can be appended to |callbacks| during this loop if a |
| // callback calls GetFrameDataOnIO(). |
| for (auto it = callbacks.callbacks.begin(); it != callbacks.callbacks.end(); |
| ++it) { |
| it->Run(cached_frame_data); |
| } |
| callbacks_map_.erase(key); |
| } |
| |
| void ExtensionApiFrameIdMap::GetFrameDataOnIO( |
| int render_process_id, |
| int frame_routing_id, |
| const FrameDataCallback& callback) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| // TODO(robwu): Enable assertion when all callers have been fixed. |
| // DCHECK_EQ(MSG_ROUTING_NONE, -1); |
| if (!IsFrameRoutingIdValid(frame_routing_id)) { |
| callback.Run(FrameData()); |
| return; |
| } |
| |
| FrameData cached_frame_data; |
| bool did_find_cached_frame_data = GetCachedFrameDataOnIO( |
| render_process_id, frame_routing_id, &cached_frame_data); |
| |
| const RenderFrameIdKey key(render_process_id, frame_routing_id); |
| auto map_iter = callbacks_map_.find(key); |
| |
| if (did_find_cached_frame_data) { |
| // Value already cached, thread hopping is not needed. |
| if (map_iter == callbacks_map_.end()) { |
| // If the frame ID was cached, then it is likely that there are no pending |
| // callbacks. So do not unnecessarily copy the callback, but run it. |
| callback.Run(cached_frame_data); |
| } else { |
| map_iter->second.callbacks.push_back(callback); |
| ReceivedFrameDataOnIO(key, cached_frame_data); |
| } |
| return; |
| } |
| |
| // The key was seen for the first time (or the frame has been removed). |
| // Hop to the UI thread to look up the extension API frame ID. |
| callbacks_map_[key].callbacks.push_back(callback); |
| base::PostTaskWithTraitsAndReplyWithResult( |
| FROM_HERE, {content::BrowserThread::UI}, |
| base::Bind(&ExtensionApiFrameIdMap::LookupFrameDataOnUI, |
| base::Unretained(this), key, true /* is_from_io */), |
| base::Bind(&ExtensionApiFrameIdMap::ReceivedFrameDataOnIO, |
| base::Unretained(this), key)); |
| } |
| |
| bool ExtensionApiFrameIdMap::GetCachedFrameDataOnIO(int render_process_id, |
| int frame_routing_id, |
| FrameData* frame_data_out) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::IO); |
| |
| // TODO(robwu): Enable assertion when all callers have been fixed. |
| // DCHECK_EQ(MSG_ROUTING_NONE, -1); |
| if (!IsFrameRoutingIdValid(frame_routing_id)) |
| return false; |
| |
| // A valid routing ID is only meaningful with a valid process ID. |
| DCHECK_GE(render_process_id, 0); |
| |
| bool found = false; |
| { |
| base::AutoLock lock(frame_data_map_lock_); |
| FrameDataMap::const_iterator frame_id_iter = frame_data_map_.find( |
| RenderFrameIdKey(render_process_id, frame_routing_id)); |
| if (frame_id_iter != frame_data_map_.end()) { |
| // This is very likely to happen because CacheFrameData() is called as |
| // soon as the frame is created. |
| *frame_data_out = frame_id_iter->second; |
| found = true; |
| } |
| } |
| |
| // TODO(devlin): Depending on how the data looks, this may be removable after |
| // a few cycles. Check back in M52 to see if it's still needed. |
| UMA_HISTOGRAM_BOOLEAN("Extensions.ExtensionFrameMapCacheHit", found); |
| return found; |
| } |
| |
| ExtensionApiFrameIdMap::FrameData ExtensionApiFrameIdMap::GetFrameData( |
| content::RenderFrameHost* rfh) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| if (!rfh) |
| return FrameData(); |
| |
| const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); |
| return LookupFrameDataOnUI(key, false /* is_from_io */); |
| } |
| |
| void ExtensionApiFrameIdMap::InitializeRenderFrameData( |
| content::RenderFrameHost* rfh) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(rfh); |
| DCHECK(rfh->IsRenderFrameLive()); |
| |
| const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); |
| CacheFrameData(key); |
| DCHECK(frame_data_map_.find(key) != frame_data_map_.end()); |
| } |
| |
| void ExtensionApiFrameIdMap::CacheFrameData(const RenderFrameIdKey& key) { |
| LookupFrameDataOnUI(key, false /* is_from_io */); |
| } |
| |
| void ExtensionApiFrameIdMap::OnRenderFrameDeleted( |
| content::RenderFrameHost* rfh) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(rfh); |
| |
| const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); |
| RemoveFrameData(key); |
| } |
| |
| void ExtensionApiFrameIdMap::UpdateTabAndWindowId( |
| int tab_id, |
| int window_id, |
| content::RenderFrameHost* rfh) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(rfh); |
| const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); |
| |
| // Only track FrameData for live render frames. |
| if (!rfh->IsRenderFrameLive()) { |
| return; |
| } |
| |
| base::AutoLock lock(frame_data_map_lock_); |
| auto iter = frame_data_map_.find(key); |
| // The FrameData for |rfh| should have already been initialized. |
| DCHECK(iter != frame_data_map_.end()); |
| iter->second.tab_id = tab_id; |
| iter->second.window_id = window_id; |
| } |
| |
| void ExtensionApiFrameIdMap::OnMainFrameReadyToCommitNavigation( |
| content::NavigationHandle* navigation_handle) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(navigation_handle->IsInMainFrame()); |
| |
| bool did_insert = false; |
| std::tie(std::ignore, did_insert) = |
| ready_to_commit_document_navigations_.insert(navigation_handle); |
| DCHECK(did_insert); |
| |
| content::RenderFrameHost* main_frame = |
| navigation_handle->GetRenderFrameHost(); |
| DCHECK(main_frame); |
| |
| // We only track live frames. |
| if (!main_frame->IsRenderFrameLive()) |
| return; |
| |
| const RenderFrameIdKey key(main_frame->GetProcess()->GetID(), |
| main_frame->GetRoutingID()); |
| base::AutoLock lock(frame_data_map_lock_); |
| auto iter = frame_data_map_.find(key); |
| |
| // We must have already cached the FrameData for this in |
| // InitializeRenderFrameHost. |
| DCHECK(iter != frame_data_map_.end()); |
| iter->second.pending_main_frame_url = navigation_handle->GetURL(); |
| } |
| |
| void ExtensionApiFrameIdMap::OnMainFrameDidFinishNavigation( |
| content::NavigationHandle* navigation_handle) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| DCHECK(navigation_handle->IsInMainFrame()); |
| |
| bool did_fire_ready_to_commit_navigation = |
| !!ready_to_commit_document_navigations_.erase(navigation_handle); |
| |
| // It's safe to call NavigationHandle::GetRenderFrameHost here iff the |
| // navigation committed or a ReadyToCommitNavigation event was dispatched for |
| // this navigation. |
| // Note a RenderFrameHost might not be associated with the NavigationHandle in |
| // WebContentsObserver::DidFinishNavigation. This might happen when the |
| // navigation doesn't commit which might happen for a variety of reasons like |
| // the network network request to fetch the navigation url failed, the |
| // navigation was cancelled, by say a NavigationThrottle etc. |
| // There's nothing to do if the RenderFrameHost can't be fetched for this |
| // navigation. |
| bool can_fetch_render_frame_host = |
| navigation_handle->HasCommitted() || did_fire_ready_to_commit_navigation; |
| if (!can_fetch_render_frame_host) |
| return; |
| |
| content::RenderFrameHost* main_frame = |
| navigation_handle->GetRenderFrameHost(); |
| DCHECK(main_frame); |
| |
| // We only track live frames. |
| if (!main_frame->IsRenderFrameLive()) |
| return; |
| |
| const RenderFrameIdKey key(main_frame->GetProcess()->GetID(), |
| main_frame->GetRoutingID()); |
| base::AutoLock lock(frame_data_map_lock_); |
| auto iter = frame_data_map_.find(key); |
| |
| // We must have already cached the FrameData for this in |
| // InitializeRenderFrameHost. |
| DCHECK(iter != frame_data_map_.end()); |
| iter->second.last_committed_main_frame_url = |
| main_frame->GetLastCommittedURL(); |
| iter->second.pending_main_frame_url = base::nullopt; |
| } |
| |
| bool ExtensionApiFrameIdMap::HasCachedFrameDataForTesting( |
| content::RenderFrameHost* rfh) const { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| if (!rfh) |
| return false; |
| |
| const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID()); |
| return frame_data_map_.find(key) != frame_data_map_.end(); |
| } |
| |
| size_t ExtensionApiFrameIdMap::GetFrameDataCountForTesting() const { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| return frame_data_map_.size(); |
| } |
| |
| void ExtensionApiFrameIdMap::RemoveFrameData(const RenderFrameIdKey& key) { |
| DCHECK_CURRENTLY_ON(content::BrowserThread::UI); |
| |
| base::AutoLock lock(frame_data_map_lock_); |
| frame_data_map_.erase(key); |
| } |
| |
| } // namespace extensions |