Declarative content scripts: Renderer-side: per-extension shared memory regions (lazily loaded)

extensions/renderer/user_script_set_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_USER_SCRIPT_SET_MANAGER_H_
+#define EXTENSIONS_RENDERER_USER_SCRIPT_SET_MANAGER_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+#include "base/memory/linked_ptr.h"
+#include "base/memory/scoped_vector.h"
+#include "base/memory/shared_memory.h"
+#include "base/observer_list.h"
+#include "content/public/renderer/render_process_observer.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/user_script.h"
+
+namespace IPC {
+
+class Message;
+
+}  // namespace IPC
+
+namespace blink {
+
+class WebFrame;
+
+}  // namespace blink
+
+namespace extensions {
+
+class ExtensionSet;
+class ScriptInjection;
+class UserScriptSet;
+
+// Manager for separate UserScriptSets, one for each shared memory region.
+// Regions are organized as follows:
+// static_scripts -- contains all extensions' scripts that are statically
+//                   declared in the extension manifest.
+// programmatic_scripts -- one region per script, instantiated lazily;

[Jeffrey Yasskin, 2014/07/24 21:09:20]

"lazily" isn't precise. Do you mean that each one is created when the extension
actually uses the declarativeContent API to declare a content script, or that
they're created the first time an extension runs code in the renderer? I think
the first is ok, although we may need to merge some of them later, but for the
second I'm worried about the file descriptor usage.

[Mark Dittmer, 2014/07/25 15:09:05]

Good point on precision of language. I mean the first, so it should be fine. We
can talk about this via chat/email.

+//                         contains the extension's programmatically
+//                         declared scripts.
+class UserScriptSetManager : public content::RenderProcessObserver {
+ public:
+  // Like a UserScriptSet::Observer, but automatically subscribes to all sets
+  // associated with the manager.
+  class Observer {
+   public:
+    virtual void OnUserScriptsUpdated(
+        const std::set<std::string>& changed_extensions,
+        const std::vector<UserScript*>& scripts) = 0;
+  };
+
+  UserScriptSetManager(const ExtensionSet* extensions);
+
+  virtual ~UserScriptSetManager();
+
+  // ScopedObserver Source implementation.
+  void AddObserver(Observer* observer);
+  void RemoveObserver(Observer* observer);
+
+  // content::RenderProcessObserver implementation.
+  virtual bool OnControlMessageReceived(const IPC::Message& message) OVERRIDE;
+
+  const UserScriptSet* static_scripts() const { return static_scripts_.get(); }
+
+  const linked_ptr<UserScriptSet> ProgrammaticScripts(

[Jeffrey Yasskin, 2014/07/24 21:09:20]

Generally don't return linked_ptr<>s. They're used to be able to put
non-copyable types in STL containers, but you shouldn't use them to share
ownership. Can you return a raw pointer here?

[Mark Dittmer, 2014/07/25 15:09:05]

Yes. Raw pointers are fine here. Done.

+      const ExtensionId& extensionId);
+
+  // Get injections from |static_scripts| and each of |programmatic_scripts|.

[Jeffrey Yasskin, 2014/07/24 21:09:20]

What's this function do with its other arguments?

+  void GetAllInjections(ScopedVector<ScriptInjection>* injections,
+                        blink::WebFrame* web_frame,
+                        int tab_id,
+                        UserScript::RunLocation run_location);
+
+  // Get active extension IDs from |static_scripts| and each of
+  // |programmatic_scripts|.
+  void GetAllActiveExtensionIds(std::set<std::string>* ids) const;
+
+ private:
+  // Map for per-extension sets that may be defined programmatically.
+  typedef std::map<ExtensionId, linked_ptr<UserScriptSet> > UserScriptSetMap;
+
+  // Handle the UpdateUserScripts extension message.
+  void OnUpdateUserScripts(base::SharedMemoryHandle shared_memory,
+                           const ExtensionId& extension_id,
+                           const std::set<std::string>& changed_extensions);
+
+  // Scripts statically defined in extension manifests.
+  scoped_ptr<UserScriptSet> static_scripts_;

[Jeffrey Yasskin, 2014/07/24 21:09:20]

You can store a UserScriptSet by value, rather than through a scoped_ptr.

[Mark Dittmer, 2014/07/25 15:09:05]

Added clarifying comment. This wraps UserScriptSet::GetInjections(), fetching
all injections for static and programmatic scripts.

+
+  // Scripts programmatically defined through API calls (initialized and stored
+  // per-extension).
+  UserScriptSetMap programmatic_scripts_;
+
+  // The set of all known extensions. Owned by the Dispatcher.
+  const ExtensionSet* extensions_;
+
+  // The associated observers.
+  ObserverList<Observer> observers_;
+};
+
+}  // namespace extensions
+
+#endif  // EXTENSIONS_RENDERER_USER_SCRIPT_SET_MANAGER_H_