Add a dependency from Gin to base

gin/modules/module_registry.cc

 // Copyright 2013 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.
 
 #include "gin/modules/module_registry.h"
 
-#include <assert.h>
 #include <string>
 #include <vector>
+#include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
 #include "gin/per_isolate_data.h"
 #include "gin/wrapper_info.h"
 
 using v8::External;
 using v8::Handle;
 using v8::Isolate;
 using v8::ObjectTemplate;
 
@@ skipping 77 matching lines @@
 }
 
 void ModuleRegistry::RegisterGlobals(v8::Isolate* isolate,
                                      Handle<v8::ObjectTemplate> templ) {
   templ->Set(StringToSymbol(isolate, "define"), GetDefineTemplate(isolate));
 }
 
 void ModuleRegistry::AddBuiltinModule(Isolate* isolate,
                                       const std::string& id,
                                       Handle<ObjectTemplate> templ) {
-  assert(!id.empty());
+  DCHECK(!id.empty());
   Handle<v8::Object> modules = v8::Local<v8::Object>::New(isolate, modules_);
   modules->Set(StringToV8(isolate, id), templ->NewInstance());
 }
 
 ModuleRegistry* ModuleRegistry::From(Handle<v8::Context> context) {
   v8::Isolate* isolate = context->GetIsolate();
   Handle<v8::String> key = GetHiddenValueKey(isolate);
   Handle<v8::Value> value = context->Global()->GetHiddenValue(key);
   Handle<v8::External> external;
   if (value.IsEmpty() || !ConvertFromV8(value, &external)) {
     PerContextData* data = PerContextData::From(context);
     if (!data)
       return NULL;
     ModuleRegistry* registry = new ModuleRegistry(isolate);
     context->Global()->SetHiddenValue(key, v8::External::New(registry));
-    data->AddSupplement(registry);
+    data->AddSupplement(scoped_ptr<ContextSupplement>(registry));
     return registry;
   }
   return static_cast<ModuleRegistry*>(external->Value());
 }
 
 void ModuleRegistry::AddPendingModule(v8::Isolate* isolate,
                                       PendingModule* pending) {
   if (AttemptToLoad(isolate, pending))
     AttemptToLoadPendingModules(isolate);
 }
@@ skipping 45 matching lines @@
 void ModuleRegistry::AttemptToLoadPendingModules(v8::Isolate* isolate) {
   PendingModuleList pending_modules;
   pending_modules.swap(pending_modules_);
   for (PendingModuleList::iterator it = pending_modules.begin();
        it != pending_modules.end(); ++it) {
     AttemptToLoad(isolate, *it);
   }
 }
 
 }  // namespace gin