Cleanup: Fix some lint/style errors in extensions code.

extensions/browser/extension_prefs.cc

 // 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.
 
 #include "extensions/browser/extension_prefs.h"
 
 #include <iterator>
 
 #include "base/command_line.h"
 #include "base/prefs/pref_notifier.h"
@@ skipping 851 matching lines @@
 void ExtensionPrefs::SetActiveBit(const std::string& extension_id,
                                   bool active) {
   UpdateExtensionPref(extension_id, kActiveBit,
                       new base::FundamentalValue(active));
 }
 
 void ExtensionPrefs::MigratePermissions(const ExtensionIdList& extension_ids) {
   PermissionsInfo* info = PermissionsInfo::GetInstance();
   for (ExtensionIdList::const_iterator ext_id =
        extension_ids.begin(); ext_id != extension_ids.end(); ++ext_id) {
-
     // An extension's granted permissions need to be migrated if the
     // full_access bit is present. This bit was always present in the previous
     // scheme and is never present now.
     bool full_access;
     const base::DictionaryValue* ext = GetExtensionPref(*ext_id);
     if (!ext || !ext->GetBoolean(kPrefOldGrantedFullAccess, &full_access))
       continue;
 
     // Remove the full access bit (empty list will get trimmed).
     UpdateExtensionPref(
         *ext_id, kPrefOldGrantedFullAccess, new base::ListValue());
 
     // Add the plugin permission if the full access bit was set.
     if (full_access) {
       const base::ListValue* apis = NULL;
       base::ListValue* new_apis = NULL;
 
-      std::string granted_apis =
-          JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
+      std::string granted_apis = JoinPrefs(kPrefGrantedPermissions, kPrefAPIs);
       if (ext->GetList(kPrefOldGrantedAPIs, &apis))
         new_apis = apis->DeepCopy();
       else
         new_apis = new base::ListValue();
 
-      std::string plugin_name = info->GetByID(
-          APIPermission::kPlugin)->name();
+      std::string plugin_name = info->GetByID(APIPermission::kPlugin)->name();
       new_apis->Append(new base::StringValue(plugin_name));
       UpdateExtensionPref(*ext_id, granted_apis, new_apis);
     }
 
     // The granted permissions originally only held the effective hosts,
     // which are a combination of host and user script host permissions.
     // We now maintain these lists separately. For migration purposes, it
     // does not matter how we treat the old effective hosts as long as the
     // new effective hosts will be the same, so we move them to explicit
     // host permissions.
@@ skipping 755 matching lines @@
   return ext;
 }
 
 void ExtensionPrefs::SetGeometryCache(
     const std::string& extension_id,
     scoped_ptr<base::DictionaryValue> cache) {
   UpdateExtensionPref(extension_id, kPrefGeometryCache, cache.release());
 }
 
 const base::DictionaryValue* ExtensionPrefs::GetInstallSignature() {
- return prefs_->GetDictionary(kInstallSignature);
+  return prefs_->GetDictionary(kInstallSignature);
 }
 
 void ExtensionPrefs::SetInstallSignature(
     const base::DictionaryValue* signature) {
   if (signature) {
     prefs_->Set(kInstallSignature, *signature);
     DVLOG(1) << "SetInstallSignature - saving";
   } else {
     DVLOG(1) << "SetInstallSignature - clearing";
     prefs_->ClearPref(kInstallSignature);
@@ skipping 220 matching lines @@
     is_enabled = initial_state == Extension::ENABLED;
   }
 
   extension_pref_value_map_->RegisterExtension(extension_id, install_time,
                                                is_enabled);
   content_settings_store_->RegisterExtension(extension_id, install_time,
                                              is_enabled);
 }
 
 }  // namespace extensions