Extensions: suspend extension's scripts when V8 is paused

extensions/renderer/script_injection_manager.h

 // Copyright 2014 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_RENDERER_SCRIPT_INJECTION_MANAGER_H_
 #define EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 27 matching lines @@
 // load point, and injecting them when ready.
 class ScriptInjectionManager : public UserScriptSetManager::Observer {
  public:
   ScriptInjectionManager(const ExtensionSet* extensions,
                          UserScriptSetManager* user_script_set_manager);
   virtual ~ScriptInjectionManager();
 
   // Notifies that a new render view has been created.
   void OnRenderViewCreated(content::RenderView* render_view);
 
+  // Notifies that an injection has been finished

[Devlin, 2015/03/03 00:34:10]

nit: needs a period (same for below)

[kozy, 2015/03/03 13:50:20]

Done.

+  void OnInjectionFinished(ScriptInjection* injection);
+
  private:
   // A RenderViewObserver implementation which watches the various render views
   // in order to notify the ScriptInjectionManager of different document load
   // states.
   class RVOHelper;
 
   typedef std::map<blink::WebFrame*, UserScript::RunLocation> FrameStatusMap;
 
   // UserScriptSetManager::Observer implementation.
   void OnUserScriptsUpdated(const std::set<std::string>& changed_extensions,
                             const std::vector<UserScript*>& scripts) override;
 
   // Notifies that an RVOHelper should be removed.
   void RemoveObserver(RVOHelper* helper);
 
   // Invalidate any pending tasks associated with |frame|.
   void InvalidateForFrame(blink::WebFrame* frame);
 
-  // Returns true if the given |frame| is still valid.
-  bool IsFrameValid(blink::WebFrame* frame) const;
-
   // Starts the process to inject appropriate scripts into |frame|.
   void StartInjectScripts(blink::WebFrame* frame,
                           UserScript::RunLocation run_location);
 
   // Actually injects the scripts into |frame|.
   void InjectScripts(blink::WebFrame* frame,
                      UserScript::RunLocation run_location);
 
+  // Try to inject and store injection if it has not finished
+  void TryToInject(scoped_ptr<ScriptInjection> injection,
+                   UserScript::RunLocation run_location,
+                   ScriptsRunInfo* scripts_run_info);
+
   // Handle the ExecuteCode extension message.
   void HandleExecuteCode(const ExtensionMsg_ExecuteCode_Params& params,
                          content::RenderView* render_view);
 
   // Handle the ExecuteDeclarativeScript extension message.
   void HandleExecuteDeclarativeScript(blink::WebFrame* web_frame,
                                       int tab_id,
                                       const ExtensionId& extension_id,
                                       int script_id,
                                       const GURL& url);
 
   // Handle the GrantInjectionPermission extension message.
   void HandlePermitScriptInjection(int64 request_id);
 
   // Extensions metadata, owned by Dispatcher (which owns this object).
   const ExtensionSet* extensions_;
 
   // The map of active web frames to their corresponding statuses. The
   // RunLocation of the frame corresponds to the last location that has ran.
   FrameStatusMap frame_statuses_;
 
   // The collection of RVOHelpers.
   ScopedVector<RVOHelper> rvo_helpers_;
 
-  // True when the manager is actively injecting scripts into a web frame.
-  bool injecting_scripts_;
-
-  // The set of extensions that have been updated (and thus any injections have
-  // been invalidated) while the manager was |injecting_scripts_|.
-  std::set<std::string> invalidated_while_injecting_;
-
   // The set of UserScripts associated with extensions. Owned by the Dispatcher.
   UserScriptSetManager* user_script_set_manager_;
 
   // Pending injections which are waiting for either the proper run location or
   // user consent.
   ScopedVector<ScriptInjection> pending_injections_;
 
+  // Running injections which are waiting for async callbacks from blink
+  ScopedVector<ScriptInjection> running_injections_;
+
   ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>
       user_script_set_manager_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ScriptInjectionManager);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_