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/memory/shared_memory.h"
  15 #include "base/scoped_observer.h"
  16 #include "extensions/common/user_script.h"
  17 #include "extensions/renderer/script_injection.h"
  18 #include "extensions/renderer/user_script_set_manager.h"
  19
  20 struct ExtensionMsg_ExecuteCode_Params;
  21
  22 namespace blink {
  23 class WebFrame;
  24 class WebLocalFrame;
  25 }
  26
  27 namespace content {
  28 class RenderView;
  29 }
  30
  31 namespace extensions {
  32 class Extension;
  33 class ExtensionSet;
  34
  35 // The ScriptInjectionManager manages extensions injecting scripts into frames
  36 // via both content/user scripts and tabs.executeScript(). It is responsible for
  37 // maintaining any pending injections awaiting permission or the appropriate
  38 // load point, and injecting them when ready.
  39 class ScriptInjectionManager : public UserScriptSetManager::Observer {
  40  public:
  41   ScriptInjectionManager(const ExtensionSet* extensions,
  42                          UserScriptSetManager* user_script_set_manager);
  43   virtual ~ScriptInjectionManager();
  44
  45   // Notifies that a new render view has been created.
  46   void OnRenderViewCreated(content::RenderView* render_view);
  47
  48  private:
  49   // A RenderViewObserver implementation which watches the various render views
  50   // in order to notify the ScriptInjectionManager of different document load
  51   // states.
  52   class RVOHelper;
  53
  54   typedef std::map<blink::WebFrame*, UserScript::RunLocation> FrameStatusMap;
  55
  56   // UserScriptSetManager::Observer implementation.
  57   void OnUserScriptsUpdated(const std::set<std::string>& changed_extensions,
  58                             const std::vector<UserScript*>& scripts) override;
  59
  60   // Notifies that an RVOHelper should be removed.
  61   void RemoveObserver(RVOHelper* helper);
  62
  63   // Invalidate any pending tasks associated with |frame|.
  64   void InvalidateForFrame(blink::WebFrame* frame);
  65
  66   // Returns true if the given |frame| is still valid.
  67   bool IsFrameValid(blink::WebFrame* frame) const;
  68
  69   // Starts the process to inject appropriate scripts into |frame|.
  70   void StartInjectScripts(blink::WebFrame* frame,
  71                           UserScript::RunLocation run_location);
  72
  73   // Actually injects the scripts into |frame|.
  74   void InjectScripts(blink::WebFrame* frame,
  75                      UserScript::RunLocation run_location);
  76
  77   // Handle the ExecuteCode extension message.
  78   void HandleExecuteCode(const ExtensionMsg_ExecuteCode_Params& params,
  79                          content::RenderView* render_view);
  80
  81   // Handle the ExecuteDeclarativeScript extension message.
  82   void HandleExecuteDeclarativeScript(blink::WebFrame* web_frame,
  83                                       int tab_id,
  84                                       const ExtensionId& extension_id,
  85                                       int script_id,
  86                                       const GURL& url);
  87
  88   // Handle the GrantInjectionPermission extension message.
  89   void HandlePermitScriptInjection(int64 request_id);
  90
  91   // Extensions metadata, owned by Dispatcher (which owns this object).
  92   const ExtensionSet* extensions_;
  93
  94   // The map of active web frames to their corresponding statuses. The
  95   // RunLocation of the frame corresponds to the last location that has ran.
  96   FrameStatusMap frame_statuses_;
  97
  98   // The collection of RVOHelpers.
  99   ScopedVector<RVOHelper> rvo_helpers_;
 100
 101   // True when the manager is actively injecting scripts into a web frame.
 102   bool injecting_scripts_;
 103
 104   // The set of extensions that have been updated (and thus any injections have
 105   // been invalidated) while the manager was |injecting_scripts_|.
 106   std::set<std::string> invalidated_while_injecting_;
 107
 108   // The set of UserScripts associated with extensions. Owned by the Dispatcher.
 109   UserScriptSetManager* user_script_set_manager_;
 110
 111   // Pending injections which are waiting for either the proper run location or
 112   // user consent.
 113   ScopedVector<ScriptInjection> pending_injections_;
 114
 115   ScopedObserver<UserScriptSetManager, UserScriptSetManager::Observer>
 116       user_script_set_manager_observer_;
 117
 118   DISALLOW_COPY_AND_ASSIGN(ScriptInjectionManager);
 119 };
 120
 121 }  // namespace extensions
 122
 123 #endif  // EXTENSIONS_RENDERER_SCRIPT_INJECTION_MANAGER_H_