Convert LOG(INFO) to VLOG(1) - tools/.

tools/memory_watcher/preamble_patcher.cc

-/* Copyright (c) 2007, Google Inc.
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- *
- *     * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above
- * copyright notice, this list of conditions and the following disclaimer
- * in the documentation and/or other materials provided with the
- * distribution.
- *     * Neither the name of Google Inc. nor the names of its
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * ---
- *
- * Implementation of PreamblePatcher
- */
+// Copyright (c) 2010 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 "preamble_patcher.h"
 #include "memory_hook.h"
 #include "mini_disassembler.h"
 
 // compatibility shims
 #include "base/logging.h"
 
 // Definitions of assembly statements we need
 #define ASM_JMP32REL 0xE9
@@ skipping 40 matching lines @@
     ASSERT(false, "Failed to restore protection to target function.");
     // We must not return an error here because the function has actually
     // been patched, and returning an error would likely cause our client
     // code not to unpatch it.  So we just keep going.
   }
 
   // Flush the instruction cache to make sure the processor doesn't execute the
   // old version of the instructions (before our patch).
   //
   // FlushInstructionCache is actually a no-op at least on single-processor
-  // XP machines.  I'm not sure why this is so, but it is, yet I want to keep the
-  // call to the API here for correctness in case there is a difference in
+  // XP machines.  I'm not sure why this is so, but it is, yet I want to keep
+  // the call to the API here for correctness in case there is a difference in
   // some variants of Windows/hardware.
   succeeded = ::FlushInstructionCache(::GetCurrentProcess(),
                                       target_function,
                                       MAX_PREAMBLE_STUB_SIZE);
   if (!succeeded) {
     ASSERT(false, "Failed to flush instruction cache.");
     // We must not return an error here because the function has actually
     // been patched, and returning an error would likely cause our client
     // code not to unpatch it.  So we just keep going.
   }
@@ skipping 43 matching lines @@
     delete[] preamble_stub;
     return error_code;
   }
 
   *original_function_stub = reinterpret_cast<void*>(preamble_stub);
 
   // NOTE: For hooking malloc/free, we don't want to use streams which
   // allocate.  Basically, we've hooked malloc, but not necessarily
   // hooked free yet.  To do anything which uses the heap could crash
   // with a mismatched malloc/free!
-  //LOG(INFO) << "PreamblePatcher::RawPatch successfully patched 0x" <<
-  //         target_function;
+  //VLOG(1) << "PreamblePatcher::RawPatch successfully patched 0x"
+  //        << target_function;
 
   return SIDESTEP_SUCCESS;
 }
 
 SideStepError PreamblePatcher::Unpatch(void* target_function,
                                        void* replacement_function,
                                        void* original_function_stub) {
   ASSERT1(target_function && original_function_stub);
   if (!target_function || !original_function_stub) {
     return SIDESTEP_INVALID_PARAMETER;
   }
 
   // We disassemble the preamble of the _stub_ to see how many bytes we
   // originally copied to the stub.
   MiniDisassembler disassembler;
   unsigned int preamble_bytes = 0;
   while (preamble_bytes < 5) {
-    InstructionType instruction_type =
-      disassembler.Disassemble(
-        reinterpret_cast<unsigned char*>(original_function_stub) + preamble_bytes,
-        preamble_bytes);
+    InstructionType instruction_type = disassembler.Disassemble(
+        reinterpret_cast<unsigned char*>(original_function_stub) +
+        preamble_bytes, preamble_bytes);
     if (IT_GENERIC != instruction_type) {
       ASSERT(false, "Should only have generic instructions in stub!!");
       return SIDESTEP_UNSUPPORTED_INSTRUCTION;
     }
   }
 
   // Before unpatching, target_function should be a JMP to
   // replacement_function.  If it's not, then either it's an error, or
   // we're falling into the case where the original instruction was a
   // JMP, and we patched the jumped_to address rather than the JMP
@@ skipping 52 matching lines @@
   //
   // See comment on FlushInstructionCache elsewhere in this file.
   succeeded = ::FlushInstructionCache(::GetCurrentProcess(),
                                       target,
                                       MAX_PREAMBLE_STUB_SIZE);
   if (!succeeded) {
     ASSERT(false, "Failed to flush instruction cache.");
     return SIDESTEP_UNEXPECTED;
   }
 
-  LOG(INFO) << "PreamblePatcher::Unpatch successfully unpatched 0x" <<
-           target_function;
+  VLOG(1) << "PreamblePatcher::Unpatch successfully unpatched 0x"
+          << target_function;
   return SIDESTEP_SUCCESS;
 }
 
 };  // namespace sidestep