webRequest: reliably determine tabId

extensions/browser/extension_api_frame_id_map.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_EXTENSION_API_FRAME_ID_MAP_H_
 #define EXTENSIONS_BROWSER_EXTENSION_API_FRAME_ID_MAP_H_
 
 #include <list>
 #include <map>
 #include <memory>
@@ skipping 86 matching lines @@
   // Get the extension API frame ID for the parent of |navigation_handle|.
   static int GetParentFrameId(content::NavigationHandle* navigation_handle);
 
   // Find the current RenderFrameHost for a given WebContents and extension
   // frame ID.
   // Returns nullptr if not found.
   static content::RenderFrameHost* GetRenderFrameHostById(
       content::WebContents* web_contents,
       int frame_id);
 
-  // Runs |callback| with the result that is equivalent to calling GetFrameId()
+  // Runs |callback| with a result that is equivalent to calling GetFrameData()
   // on the UI thread. Thread hopping is minimized if possible. Callbacks for
   // the same |render_process_id| and |frame_routing_id| are guaranteed to be
   // run in order. The order of other callbacks is undefined.
   void GetFrameDataOnIO(int render_process_id,
                         int frame_routing_id,
                         const FrameDataCallback& callback);
 
   // Attempts to populate |frame_data_out| with the FrameData for the specified
   // frame, but only does so if the data is already cached. Returns true if
   // cached frame data was found.
   bool GetCachedFrameDataOnIO(int render_process_id,
                               int frame_routing_id,
                               FrameData* frame_data_out);
 
-  // Looks up the frame ID and stores it in the map. This method should be
+  // Retrieves the FrameData for a given |rfh|. The map may be updated with the
+  // result if the map did not contain the FrameData before the lookup.
+  FrameData GetFrameData(content::RenderFrameHost* rfh) WARN_UNUSED_RESULT;
+
+  // Looks up the FrameData and stores it in the map. This method should be
   // called as early as possible, e.g. in a
   // WebContentsObserver::RenderFrameCreated notification.
   void CacheFrameData(content::RenderFrameHost* rfh);
 
-  // Removes the frame ID mapping for a given frame. This method can be called
+  // Removes the FrameData mapping for a given frame. This method can be called
   // at any time, but it is typically called when a frame is destroyed.
   // If this method is not called, the cached mapping for the frame is retained
   // forever.
   void RemoveFrameData(content::RenderFrameHost* rfh);
 
   // Updates the tab and window id for the given RenderFrameHost, if any exists.
   void UpdateTabAndWindowId(int tab_id,
                             int window_id,
                             content::RenderFrameHost* rfh);
 
@@ skipping 27 matching lines @@
     // To avoid re-entrant processing of callbacks.
     bool is_iterating;
   };
 
   using FrameDataMap = std::map<RenderFrameIdKey, FrameData>;
   using FrameDataCallbacksMap = std::map<RenderFrameIdKey, FrameDataCallbacks>;
 
   ExtensionApiFrameIdMap();
   virtual ~ExtensionApiFrameIdMap();
 
-  // Determines the value to be stored in |frame_id_map_| for a given key. This
-  // method is only called when |key| is not in |frame_id_map_|.
+  // Determines the value to be stored in |frame_data_map_| for a given key.
+  // This method is only called when |key| is not in |frame_data_map_|.
   // virtual for testing.
   virtual FrameData KeyToValue(const RenderFrameIdKey& key) const;
 
   // Looks up the data for the given |key| and adds it to the |frame_data_map_|.
-  // |for_lookup| indicates whether this is for a pending lookup (as opposed to
-  // preemptively caching the frame data).
-  FrameData LookupFrameDataOnUI(const RenderFrameIdKey& key, bool for_lookup);
+  // |is_from_io| indicates whether the lookup originated from the IO thread.
+  FrameData LookupFrameDataOnUI(const RenderFrameIdKey& key, bool is_from_io);
 
-  // Called as soon as the frame ID is found for the given |key|, and runs all
-  // queued callbacks with |cached_frame_id_pair|.
+  // Called as soon as the frame data is found for the given |key|, and runs all
+  // queued callbacks with |cached_frame_data|.
   void ReceivedFrameDataOnIO(const RenderFrameIdKey& key,
-                             const FrameData& cached_frame_id_pair);
+                             const FrameData& cached_frame_data);
 
-  // Implementation of CacheFrameId(RenderFrameHost), separated for testing.
+  // Implementation of CacheFrameData(RenderFrameHost), separated for testing.
   void CacheFrameData(const RenderFrameIdKey& key);
 
-  // Implementation of RemoveFrameId(RenderFrameHost), separated for testing.
+  // Implementation of RemoveFrameData(RenderFrameHost), separated for testing.
   void RemoveFrameData(const RenderFrameIdKey& key);
 
   std::unique_ptr<ExtensionApiFrameIdMapHelper> helper_;
 
   // Queued callbacks for use on the IO thread.
   FrameDataCallbacksMap callbacks_map_;
 
   // This map is only modified on the UI thread and is used to minimize the
   // number of thread hops on the IO thread.
   FrameDataMap frame_data_map_;
 
-  // This lock protects |frame_id_map_| from being concurrently written on the
+  // This lock protects |frame_data_map_| from being concurrently written on the
   // UI thread and read on the IO thread.
   base::Lock frame_data_map_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionApiFrameIdMap);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_EXTENSION_API_FRAME_ID_MAP_H_