webRequest: reliably determine tabId

extensions/browser/extension_api_frame_id_map.cc

 // 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 "base/metrics/histogram_macros.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 92 matching lines @@
     return kInvalidFrameId;
   if (rfh->GetParent())
     return rfh->GetFrameTreeNodeId();
   return kTopFrameId;
 }
 
 // static
 int ExtensionApiFrameIdMap::GetFrameId(
     content::NavigationHandle* navigation_handle) {
   return navigation_handle->IsInMainFrame()
-             ? 0
+             ? 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 -1;
+    return kInvalidFrameId;
 
   if (navigation_handle->IsParentMainFrame())
-    return 0;
+    return kTopFrameId;
 
   return navigation_handle->GetParentFrameTreeNodeId();
 }
 
 // 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
@@ skipping 17 matching lines @@
       key.render_process_id, key.frame_routing_id);
   int tab_id = -1;
   int window_id = -1;
   if (helper_)
     helper_->GetTabAndWindowId(rfh, &tab_id, &window_id);
   return FrameData(GetFrameId(rfh), GetParentFrameId(rfh), tab_id, window_id);
 }
 
 ExtensionApiFrameIdMap::FrameData ExtensionApiFrameIdMap::LookupFrameDataOnUI(
     const RenderFrameIdKey& key,
-    bool for_lookup) {
+    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 (for_lookup) {
+  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);
 
   FrameDataCallbacksMap::iterator map_iter = callbacks_map_.find(key);
   if (map_iter == callbacks_map_.end()) {
-    // Can happen if ReceivedFrameIdOnIO was called after the frame ID was
+    // 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;
@@ skipping 47 matching lines @@
     }
     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);
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::UI, FROM_HERE,
       base::Bind(&ExtensionApiFrameIdMap::LookupFrameDataOnUI,
-                 base::Unretained(this), key, true /* for lookup */),
+                 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 CacheFrameId() is called as soon
-      // as the frame is created.
+      // 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);
+
+  const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID());
+  return LookupFrameDataOnUI(key, false /* is_from_io */);
+}
+
 void ExtensionApiFrameIdMap::CacheFrameData(content::RenderFrameHost* rfh) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   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 /* not for lookup */);
+  LookupFrameDataOnUI(key, false /* is_from_io */);
 }
 
 void ExtensionApiFrameIdMap::RemoveFrameData(content::RenderFrameHost* rfh) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(rfh);
 
   const RenderFrameIdKey key(rfh->GetProcess()->GetID(), rfh->GetRoutingID());
   RemoveFrameData(key);
 }
 
@@ skipping 16 matching lines @@
 }
 
 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