Make ModuleSystem have a const view of ResourceBundleSourceMap.

extensions/renderer/module_system.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_MODULE_SYSTEM_H_
 #define EXTENSIONS_RENDERER_MODULE_SYSTEM_H_
 
 #include <map>
 #include <set>
 #include <string>
@@ skipping 28 matching lines @@
 // Note that a ModuleSystem must be used only in conjunction with a single
 // v8::Context.
 // TODO(koz): Rename this to JavaScriptModuleSystem.
 class ModuleSystem : public ObjectBackedNativeHandler,
                      public gin::ModuleRegistryObserver {
  public:
   class SourceMap {
    public:
     virtual ~SourceMap() {}
     virtual v8::Local<v8::Value> GetSource(v8::Isolate* isolate,
-                                           const std::string& name) = 0;
-    virtual bool Contains(const std::string& name) = 0;
+                                           const std::string& name) const = 0;
+    virtual bool Contains(const std::string& name) const = 0;
   };
 
   class ExceptionHandler {
    public:
     explicit ExceptionHandler(ScriptContext* context) : context_(context) {}
     virtual ~ExceptionHandler() {}
     virtual void HandleUncaughtException(const v8::TryCatch& try_catch) = 0;
 
    protected:
     // Formats |try_catch| as a nice string.
     std::string CreateExceptionString(const v8::TryCatch& try_catch);
     // A script context associated with this handler. Owned by the module
     // system.
     ScriptContext* context_;
   };
 
   // Enables native bindings for the duration of its lifetime.
   class NativesEnabledScope {
    public:
     explicit NativesEnabledScope(ModuleSystem* module_system);
     ~NativesEnabledScope();
 
    private:
     ModuleSystem* module_system_;
     DISALLOW_COPY_AND_ASSIGN(NativesEnabledScope);
   };
 
   // |source_map| is a weak pointer.
-  ModuleSystem(ScriptContext* context, SourceMap* source_map);
+  ModuleSystem(ScriptContext* context, const SourceMap* source_map);
   ~ModuleSystem() override;
 
   // Require the specified module. This is the equivalent of calling
   // require('module_name') from the loaded JS files.
   v8::MaybeLocal<v8::Object> Require(const std::string& module_name);
   void Require(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   // Run |code| in the current context with the name |name| used for stack
   // traces.
   v8::Local<v8::Value> RunString(v8::Local<v8::String> code,
@@ skipping 123 matching lines @@
       const std::vector<std::string>& dependencies) override;
 
   // Marks any existing NativeHandler named |name| as clobbered.
   // See |clobbered_native_handlers_|.
   void ClobberExistingNativeHandler(const std::string& name);
 
   ScriptContext* context_;
 
   // A map from module names to the JS source for that module. GetSource()
   // performs a lookup on this map.
-  SourceMap* source_map_;
+  const SourceMap* const source_map_;
 
   // A map from native handler names to native handlers.
   NativeHandlerMap native_handler_map_;
 
   // When 0, natives are disabled, otherwise indicates how many callers have
   // pinned natives as enabled.
   int natives_enabled_;
 
   // Called when an exception is thrown but not caught in JS. Overridable by
   // tests.
@@ skipping 10 matching lines @@
   std::vector<scoped_ptr<NativeHandler>> clobbered_native_handlers_;
 
   base::WeakPtrFactory<ModuleSystem> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ModuleSystem);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_RENDERER_MODULE_SYSTEM_H_