Style cleanup in preparation for auto-linting base/.

base/registry.cc

 // Copyright (c) 2006-2008 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.
 // All Rights Reserved.
 
 #include "base/registry.h"
 
 #include <assert.h>
 #include <shlwapi.h>
 #include <windows.h>
@@ skipping 33 matching lines @@
 RegistryValueIterator::~RegistryValueIterator() {
   if (key_)
     ::RegCloseKey(key_);
 }
 
 bool RegistryValueIterator::Valid() const {
   // true while the iterator is valid
   return key_ != NULL && index_ >= 0;
 }
 
-void RegistryValueIterator::operator ++ () {
+void RegistryValueIterator::operator++() {
   // advance to the next entry in the folder
   --index_;
   Read();
 }
 
 bool RegistryValueIterator::Read() {
   if (Valid()) {
     DWORD ncount = sizeof(name_)/sizeof(*name_);
     value_size_ = sizeof(value_);
     LRESULT r = ::RegEnumValue(key_, index_, name_, &ncount, NULL, &type_,
@@ skipping 48 matching lines @@
 RegistryKeyIterator::~RegistryKeyIterator() {
   if (key_)
     ::RegCloseKey(key_);
 }
 
 bool RegistryKeyIterator::Valid() const {
   // true while the iterator is valid
   return key_ != NULL && index_ >= 0;
 }
 
-void RegistryKeyIterator::operator ++ () {
+void RegistryKeyIterator::operator++() {
   // advance to the next entry in the folder
   --index_;
   Read();
 }
 
 bool RegistryKeyIterator::Read() {
   if (Valid()) {
     DWORD ncount = sizeof(name_)/sizeof(*name_);
     FILETIME written;
     LRESULT r = ::RegEnumKeyEx(key_, index_, name_, &ncount, NULL, NULL,
@@ skipping 22 matching lines @@
 // RegKey
 //
 
 RegKey::RegKey(HKEY rootkey, const tchar* subkey, REGSAM access)
   : key_(NULL), watch_event_(0) {
   if (rootkey) {
     if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK))
       this->Create(rootkey, subkey, access);
     else
       this->Open(rootkey, subkey, access);
+  } else {
+    assert(!subkey);
   }
-  else assert(!subkey);
 }
 
 void RegKey::Close() {
   StopWatching();
   if (key_) {
     ::RegCloseKey(key_);
     key_ = NULL;
   }
 }
 
@@ skipping 13 matching lines @@
                                      NULL,
                                      REG_OPTION_NON_VOLATILE,
                                      access,
                                      NULL,
                                      &key_,
                                      disposition );
   if (result != ERROR_SUCCESS) {
     key_ = NULL;
     return false;
   }
-  else return true;
+
+  return true;
 }
 
 bool RegKey::Open(HKEY rootkey, const tchar* subkey, REGSAM access) {
   assert(rootkey && subkey && access);
   this->Close();
 
   LONG const result = RegOpenKeyEx(rootkey, subkey, 0,
                                    access, &key_ );
   if (result != ERROR_SUCCESS) {
     key_ = NULL;
     return false;
   }
-  else return true;
+
+  return true;
 }
 
 bool RegKey::CreateKey(const tchar* name, REGSAM access) {
   assert(name && access);
 
   HKEY subkey = NULL;
   LONG const result = RegCreateKeyEx(key_, name, 0, NULL,
                                      REG_OPTION_NON_VOLATILE,
                                      access, NULL, &subkey, NULL);
   this->Close();
@@ skipping 65 matching lines @@
       // Fail: other, returns 0
       if (size == 0 || size > kMaxStringLength)
         return false;
       *value = expanded;
     } else {
       // Not a string. Oops.
       return false;
     }
     return true;
   }
-  else return false;
+
+  return false;
 }
 
 bool RegKey::ReadValueDW(const tchar* name, DWORD * value) {
   assert(value);
   DWORD type = REG_DWORD, size = sizeof(DWORD), result = 0;
   if (this->ReadValue(name, &result, &size, &type)
      && (type == REG_DWORD || type == REG_BINARY)
      && size == sizeof(DWORD)) {
     *value = result;
     return true;
   }
-  else return false;
+
+  return false;
 }
 
 bool RegKey::WriteValue(const tchar* name,
                         const void * data,
                         DWORD dsize,
                         DWORD dtype) {
   assert(data);
   if (!key_) return false;
   HRESULT const result = RegSetValueEx(
       key_,
@@ skipping 85 matching lines @@
   ::GetModuleFileName(module, module_path, MAX_PATH);
   _tcslwr_s(module_path, MAX_PATH);
   return RegisterCOMServer(guid, name, module_path);
 }
 
 bool UnregisterCOMServer(const tchar* guid) {
   RegKey key(HKEY_CLASSES_ROOT, _T("CLSID"), KEY_WRITE);
   key.DeleteKey(guid);
   return true;
 }