Try to fix the memory leak reports in g_restrictions.

chrome/common/extensions/manifest.cc

 // 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.
 
 #include "chrome/common/extensions/manifest.h"
 
 #include "base/basictypes.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/string_split.h"
@@ skipping 79 matching lines @@
     return i != map.end();
   }
 
   // Returns true if the given |key| can be specified by the manifest |type|.
   bool CanAccessKey(const std::string& key, Manifest::Type type) const {
     RestrictionMap::const_iterator i = map.find(key);
     return (i != map.end() && (type & i->second) != 0);
   }
 
   RestrictionMap map;
+
+  DISALLOW_COPY_AND_ASSIGN(Restrictions);
 };
 
-base::LazyInstance<Restrictions> g_restrictions;
+static base::LazyInstance<Restrictions> g_restrictions =
+    LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
 std::set<std::string> Manifest::GetAllKnownKeys() {
   std::set<std::string> keys;
   const RestrictionMap& map = g_restrictions.Get().map;
   for (RestrictionMap::const_iterator i = map.begin(); i != map.end(); i++)
     keys.insert(i->first);
   return keys;
 }
 
 Manifest::Manifest(DictionaryValue* value) : value_(value) {}
 Manifest::~Manifest() {}
 
 bool Manifest::ValidateManifest(string16* error) const {
-  Restrictions restrictions = g_restrictions.Get();
+  const Restrictions& restrictions = g_restrictions.Get();
   Type type = GetType();
 
   for (DictionaryValue::key_iterator key = value_->begin_keys();
        key != value_->end_keys(); ++key) {
     // When validating the extension manifests, we ignore keys that are not
     // recognized for forward compatibility.
     if (!restrictions.IsKnownKey(*key)) {
       // TODO(aa): Consider having an error here in the case of strict error
       // checking to let developers know when they screw up.
       continue;
     }
 
     if (!restrictions.CanAccessKey(*key, type)) {
       *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kFeatureNotAllowed, *key);
       return false;
     }
   }
 
   return true;
 }
 
 bool Manifest::HasKey(const std::string& key) const {
-  Restrictions restrictions = g_restrictions.Get();
+  const Restrictions& restrictions = g_restrictions.Get();
   return restrictions.CanAccessKey(key, GetType()) && value_->HasKey(key);
 }
 
 bool Manifest::Get(
     const std::string& path, Value** out_value) const {
   return CanAccessPath(path) && value_->Get(path, out_value);
 }
 
 bool Manifest::GetBoolean(
     const std::string& path, bool* out_value) const {
@@ skipping 64 matching lines @@
 }
 
 bool Manifest::IsHostedApp() const {
   return GetType() == kTypeHostedApp;
 }
 
 bool Manifest::CanAccessPath(const std::string& path) const {
   std::vector<std::string> components;
   base::SplitString(path, '.', &components);
 
-  Restrictions restrictions = g_restrictions.Get();
+  const Restrictions& restrictions = g_restrictions.Get();
   return restrictions.CanAccessKey(components[0], GetType());
 }
 
 }  // namespace extensions