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

courgette/third_party/bsdiff_create.cc

 /*
   bsdiff.c -- Binary patch generator.
 
   Copyright 2003 Colin Percival
 
   For the terms under which this work may be distributed, please see
   the adjoining file "LICENSE".
 
   ChangeLog:
   2005-05-05 - Use the modified header struct from bspatch.h; use 32-bit
@@ skipping 185 matching lines @@
   stream->WriteVarint32(header->slen);
   stream->WriteVarint32(header->scrc32);
   stream->WriteVarint32(header->dlen);
 }
 
 BSDiffStatus CreateBinaryPatch(SourceStream* old_stream,
                                SourceStream* new_stream,
                                SinkStream* patch_stream)
 {
   base::Time start_bsdiff_time = base::Time::Now();
-  LOG(INFO) << "Start bsdiff";
+  VLOG(1) << "Start bsdiff";
   size_t initial_patch_stream_length = patch_stream->Length();
 
   SinkStreamSet patch_streams;
   SinkStream* control_stream_copy_counts = patch_streams.stream(0);
   SinkStream* control_stream_extra_counts = patch_streams.stream(1);
   SinkStream* control_stream_seeks = patch_streams.stream(2);
   SinkStream* diff_skips = patch_streams.stream(3);
   SinkStream* diff_bytes = patch_streams.stream(4);
   SinkStream* extra_bytes = patch_streams.stream(5);
 
@@ skipping 12 matching lines @@
   }
 
   if (!V.Allocate(oldsize + 1)) {
     LOG(ERROR) << "Could not allocate V[], " << ((oldsize + 1) * sizeof(int))
                << " bytes";
     return MEM_ERROR;
   }
 
   base::Time q_start_time = base::Time::Now();
   qsufsort(I, V, old, oldsize);
-  LOG(INFO) << " done qsufsort "
-            << (base::Time::Now() - q_start_time).InSecondsF();
+  VLOG(1) << " done qsufsort "
+          << (base::Time::Now() - q_start_time).InSecondsF();
   V.clear();
 
   const uint8* newbuf = new_stream->Buffer();
   const int newsize = new_stream->Remaining();
 
   int control_length = 0;
   int diff_bytes_length = 0;
   int diff_bytes_nonzero = 0;
   int extra_bytes_length = 0;
 
@@ skipping 140 matching lines @@
 
       uint32 copy_count = lenf;
       uint32 extra_count = gap;
       int32 seek_adjustment = ((pos - lenb) - (lastpos + lenf));
 
       control_stream_copy_counts->WriteVarint32(copy_count);
       control_stream_extra_counts->WriteVarint32(extra_count);
       control_stream_seeks->WriteVarint32Signed(seek_adjustment);
       ++control_length;
 #ifdef DEBUG_bsmedberg
-      LOG(INFO) << StringPrintf(
-          "Writing a block:  copy: %-8u extra: %-8u seek: %+-9d",
-          copy_count, extra_count, seek_adjustment);
+      VLOG(1) << StringPrintf("Writing a block:  copy: %-8u extra: %-8u seek: "
+                              "%+-9d", copy_count, extra_count,
+                              seek_adjustment);
 #endif
 
       lastscan = scan - lenb;   // Include the backward extension in seed.
       lastpos = pos - lenb;     //  ditto.
       lastoffset = lastpos - lastscan;
     }
   }
 
   diff_skips->WriteVarint32(pending_diff_zeros);
 
   I.clear();
 
   MBSPatchHeader header;
   // The string will have a null terminator that we don't use, hence '-1'.
   COMPILE_ASSERT(sizeof(MBS_PATCH_HEADER_TAG) - 1 == sizeof(header.tag),
                  MBS_PATCH_HEADER_TAG_must_match_header_field_size);
   memcpy(header.tag, MBS_PATCH_HEADER_TAG, sizeof(header.tag));
   header.slen     = oldsize;
   header.scrc32   = CalculateCrc(old, oldsize);
   header.dlen     = newsize;
 
   WriteHeader(patch_stream, &header);
 
   size_t diff_skips_length = diff_skips->Length();
   patch_streams.CopyTo(patch_stream);
 
-  LOG(INFO) << "Control tuples: " << control_length
-            << "  copy bytes: " << diff_bytes_length
-            << "  mistakes: " << diff_bytes_nonzero
-            << "  (skips: " << diff_skips_length << ")"
-            << "  extra bytes: " << extra_bytes_length;
+  VLOG(1) << "Control tuples: " << control_length
+          << "  copy bytes: " << diff_bytes_length
+          << "  mistakes: " << diff_bytes_nonzero
+          << "  (skips: " << diff_skips_length << ")"
+          << "  extra bytes: " << extra_bytes_length;
 
-  LOG(INFO) << "Uncompressed bsdiff patch size "
-            << patch_stream->Length() - initial_patch_stream_length;
+  VLOG(1) << "Uncompressed bsdiff patch size "
+          << patch_stream->Length() - initial_patch_stream_length;
 
-  LOG(INFO) << "End bsdiff "
-            << (base::Time::Now() - start_bsdiff_time).InSecondsF();
+  VLOG(1) << "End bsdiff "
+          << (base::Time::Now() - start_bsdiff_time).InSecondsF();
 
   return OK;
 }
 
 }  // namespace