Beginning of support for extension content verification

chrome/browser/extensions/user_script_master.h

 // Copyright (c) 2012 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 CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_
 #define CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_
 
 #include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_observer.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/user_script.h"
 
 namespace content {
 class RenderProcessHost;
 }
 
 class Profile;
 
 namespace extensions {
 
+class ContentVerifier;
 class ExtensionRegistry;
 
 typedef std::map<std::string, ExtensionSet::ExtensionPathAndDefaultLocale>
     ExtensionsInfo;
 
 // Manages a segment of shared memory that contains the user scripts the user
 // has installed.  Lives on the UI thread.
 class UserScriptMaster : public base::RefCountedThreadSafe<UserScriptMaster>,
                          public content::NotificationObserver,
                          public ExtensionRegistryObserver {
  public:
   explicit UserScriptMaster(Profile* profile);
 
   // Kicks off a process on the file thread to reload scripts from disk
   // into a new chunk of shared memory and notify renderers.
   virtual void StartLoad();
 
   // Gets the segment of shared memory for the scripts.
   base::SharedMemory* GetSharedMemory() const {
     return shared_memory_.get();
   }
 
   // Called by the script reloader when new scripts have been loaded.
   void NewScriptsAvailable(base::SharedMemory* handle);
 
   // Return true if we have any scripts ready.
   bool ScriptsReady() const { return shared_memory_.get() != NULL; }
 
+  // Returns the content verifier for our browser context.
+  ContentVerifier* content_verifier();
+
  protected:
   friend class base::RefCountedThreadSafe<UserScriptMaster>;
 
   virtual ~UserScriptMaster();
 
  public:
   // We reload user scripts on the file thread to prevent blocking the UI.
   // ScriptReloader lives on the file thread and does the reload
   // work, and then sends a message back to its master with a new SharedMemory*.
   // ScriptReloader is the worker that manages running the script load
   // on the file thread. It must be created on, and its public API must only be
   // called from, the master's thread.
   class ScriptReloader
       : public base::RefCountedThreadSafe<UserScriptMaster::ScriptReloader> {
    public:
     // Parses the includes out of |script| and returns them in |includes|.
     static bool ParseMetadataHeader(const base::StringPiece& script_text,
                                     UserScript* script);
 
     explicit ScriptReloader(UserScriptMaster* master);
 
     // Start loading of scripts.
     // Will always send a message to the master upon completion.
     void StartLoad(const UserScriptList& external_scripts,
-                   const ExtensionsInfo& extension_info_);
+                   const ExtensionsInfo& extensions_info);
 
     // The master is going away; don't call it back.
     void DisownMaster() {
       master_ = NULL;
     }
 
    private:
     FRIEND_TEST_ALL_PREFIXES(UserScriptMasterTest, SkipBOMAtTheBeginning);
     FRIEND_TEST_ALL_PREFIXES(UserScriptMasterTest, LeaveBOMNotAtTheBeginning);
     friend class base::RefCountedThreadSafe<UserScriptMaster::ScriptReloader>;
@@ skipping 26 matching lines @@
     // May be NULL if DisownMaster() is called.
     UserScriptMaster* master_;
 
     // Maps extension info needed for localization to an extension ID.
     ExtensionsInfo extensions_info_;
 
     // The message loop to call our master back on.
     // Expected to always outlive us.
     content::BrowserThread::ID master_thread_id_;
 
+    scoped_refptr<ContentVerifier> verifier_;
+
     DISALLOW_COPY_AND_ASSIGN(ScriptReloader);
   };
 
  private:
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // ExtensionRegistryObserver implementation.
@@ skipping 38 matching lines @@
   // Listen to extension load, unloaded notifications.
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(UserScriptMaster);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_USER_SCRIPT_MASTER_H_