extensions/renderer/script_injection_manager.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_
   6 #define EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_
   7
   8 #include <map>
   9 #include <set>
  10 #include <string>
  11
  12 #include "base/callback.h"
  13 #include "base/memory/scoped_vector.h"
  14 #include "base/scoped_observer.h"
  15 #include "extensions/common/user_script.h"
  16 #include "extensions/renderer/script_injection.h"
  17 #include "extensions/renderer/user_script_set_manager.h"
  18
  19 struct ExtensionMsg_ExecuteCode_Params;
  20
  21 namespace content {
  22 class RenderFrame;
  23 }
  24
  25 namespace extensions {
  26 class Extension;
  27
  28 // The ScriptInjectionManager manages extensions injecting scripts into frames
  29 // via both content/user scripts and tabs.executeScript(). It is responsible for
  30 // maintaining any pending injections awaiting permission or the appropriate
  31 // load point, and injecting them when ready.
  32 class ScriptInjectionManager : public UserScriptSetManager::Observer {
  33  public:
  34   explicit ScriptInjectionManager(
  35       UserScriptSetManager* user_script_set_manager);
  36   virtual ~ScriptInjectionManager();
  37
  38   // Notifies that a new render view has been created.
  39   void OnRenderFrameCreated(content::RenderFrame* render_frame);
  40
  41   // Removes pending injections of the unloaded extension.
  42   void OnExtensionUnloaded(const std::string& extension_id);
  43
  44  private:
  45   // A RenderFrameObserver implementation which watches the various render
  46   // frames in order to notify the ScriptInjectionManager of different
  47   // document load states and IPCs.
  48   class RFOHelper;
  49
  50   using FrameStatusMap =
  51       std::map<content::RenderFrame*, UserScript::RunLocation>;
  52
  53   // Notifies that an injection has been finished.
  54   void OnInjectionFinished(ScriptInjection* injection);
  55
  56   // UserScriptSetManager::Observer implementation.
  57   void OnUserScriptsUpdated(const std::set<HostID>& changed_hosts,
  58                             const std::vector<UserScript*>& scripts) override;
  59
  60   // Notifies that an RFOHelper should be removed.
  61   void RemoveObserver(RFOHelper* helper);
  62
  63   // Invalidate any pending tasks associated with |frame|.
  64   void InvalidateForFrame(content::RenderFrame* frame);
  65
  66   // Starts the process to inject appropriate scripts into |frame|.
  67   void StartInjectScripts(content::RenderFrame* frame,
  68                           UserScript::RunLocation run_location);
  69
  70   // Actually injects the scripts into |frame|.
  71   void InjectScripts(content::RenderFrame* frame,
  72                      UserScript::RunLocation run_location);
  73
  74   // Try to inject and store injection if it has not finished.
  75   void TryToInject(scoped_ptr<ScriptInjection> injection,
  76                    UserScript::RunLocation run_location,
  77                    ScriptsRunInfo* scripts_run_info);
  78
  79   // Handle the ExecuteCode extension message.
  80   void HandleExecuteCode(const ExtensionMsg_ExecuteCode_Params& params,
  81                          content::RenderFrame* render_frame);
  82
  83   // Handle the ExecuteDeclarativeScript extension message.
  84   void HandleExecuteDeclarativeScript(content::RenderFrame* web_frame,
  85                                       int tab_id,
  86                                       const ExtensionId& extension_id,
  87                                       int script_id,
  88                                       const GURL& url);
  89
  90   // Handle the GrantInjectionPermission extension message.
  91   void HandlePermitScriptInjection(int64 request_id);
  92
  93   // The map of active web frames to their corresponding statuses. The
  94   // RunLocation of the frame corresponds to the last location that has ran.
  95   FrameStatusMap frame_statuses_;
  96
  97   // The frames currently being injected into, so long as that frame is valid.
  98   std::set<content::RenderFrame*> active_injection_frames_;
  99
 100   // The collection of RFOHelpers.
 101   ScopedVector<RFOHelper> rfo_helpers_;
 102
 103   // The set of UserScripts associated with extensions. Owned by the Dispatcher.
 104   UserScriptSetManager* user_script_set_manager_;
 105
 106   // Pending injections which are waiting for either the proper run location or
 107   // user consent.
 108   ScopedVector<ScriptInjection> pending_injections_;
 109
 110   // Running injections which are waiting for async callbacks from blink.
 111   ScopedVector<ScriptInjection> running_injections_;
 112
 113   ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>
 114       user_script_set_manager_observer_;
 115
 116   DISALLOW_COPY_AND_ASSIGN(ScriptInjectionManager);
 117 };
 118
 119 }  // namespace extensions
 120
 121 #endif  // EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_