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

courgette/ensemble_create.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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.
 
 // The main idea in Courgette is to do patching *under a tranformation*.  The
 // input is transformed into a new representation, patching occurs in the new
 // repesentation, and then the tranform is reversed to get the patched data.
 //
 // The idea is applied to pieces (or 'elements') of the whole (or 'ensemble').
 // Each of the elements has to go through the same set of steps in lock-step.
 
@@ skipping 94 matching lines @@
 // |new_ensemble|.  For each element of |new_ensemble| we find the closest
 // matching element from |old_ensemble| and use that as the basis for
 // differential compression.  The elements have to be the same kind so as to
 // support transformation into the same kind of 'new representation'.
 //
 Status FindGenerators(Ensemble* old_ensemble, Ensemble* new_ensemble,
                       std::vector<TransformationPatchGenerator*>* generators) {
   base::Time start_find_time = base::Time::Now();
   old_ensemble->FindEmbeddedElements();
   new_ensemble->FindEmbeddedElements();
-  LOG(INFO) << "done FindEmbeddedElements "
-            << (base::Time::Now() - start_find_time).InSecondsF();
+  VLOG(1) << "done FindEmbeddedElements "
+          << (base::Time::Now() - start_find_time).InSecondsF();
 
   std::vector<Element*> old_elements(old_ensemble->elements());
   std::vector<Element*> new_elements(new_ensemble->elements());
 
-  LOG(INFO) << "old has " << old_elements.size() << " elements";
-  LOG(INFO) << "new has " << new_elements.size() << " elements";
+  VLOG(1) << "old has " << old_elements.size() << " elements";
+  VLOG(1) << "new has " << new_elements.size() << " elements";
 
   DifferenceEstimator difference_estimator;
   std::vector<DifferenceEstimator::Base*> bases;
 
   base::Time start_bases_time = base::Time::Now();
   for (size_t i = 0;  i < old_elements.size();  ++i) {
     bases.push_back(
         difference_estimator.MakeBase(old_elements[i]->region()));
   }
-  LOG(INFO) << "done make bases "
-            << (base::Time::Now() - start_bases_time).InSecondsF()
-            << "s";
+  VLOG(1) << "done make bases "
+          << (base::Time::Now() - start_bases_time).InSecondsF() << "s";
 
   for (size_t new_index = 0;  new_index < new_elements.size();  ++new_index) {
     Element* new_element = new_elements[new_index];
     DifferenceEstimator::Subject* new_subject =
         difference_estimator.MakeSubject(new_element->region());
 
     // Search through old elements to find the best match.
     //
     // TODO(sra): This is O(N x M), i.e. O(N^2) since old_ensemble and
     // new_ensemble probably have a very similar structure.  We can make the
@@ skipping 12 matching lines @@
       if (old_element->kind() != new_element->kind())
         continue;
 
       if (UnsafeDifference(old_element, new_element))
         continue;
 
       base::Time start_compare = base::Time::Now();
       DifferenceEstimator::Base* old_base = bases[old_index];
       size_t difference = difference_estimator.Measure(old_base, new_subject);
 
-      LOG(INFO) << "Compare " << old_element->Name()
-                << " to " << new_element->Name()
-                << " --> " << difference
-                << " in " << (base::Time::Now() - start_compare).InSecondsF()
-                << "s";
+      VLOG(1) << "Compare " << old_element->Name()
+              << " to " << new_element->Name()
+              << " --> " << difference
+              << " in " << (base::Time::Now() - start_compare).InSecondsF()
+              << "s";
       if (difference == 0) {
-        LOG(INFO) << "Skip " << new_element->Name()
-                  << " - identical to " << old_element->Name();
+        VLOG(1) << "Skip " << new_element->Name()
+                << " - identical to " << old_element->Name();
         best_difference = 0;
         best_old_element = NULL;
         break;
       }
       if (difference < best_difference) {
         best_difference = difference;
         best_old_element = old_element;
       }
     }
 
     if (best_old_element) {
-      LOG(INFO) << "Matched " << best_old_element->Name()
-                << " to " << new_element->Name()
-                << " --> " << best_difference;
+      VLOG(1) << "Matched " << best_old_element->Name()
+              << " to " << new_element->Name()
+              << " --> " << best_difference;
       TransformationPatchGenerator* generator =
           MakeGenerator(best_old_element, new_element);
       if (generator)
         generators->push_back(generator);
     }
   }
 
-  LOG(INFO) << "done FindGenerators "
-            << "found " << generators->size() << " in "
-            << (base::Time::Now() - start_find_time).InSecondsF() << "s";
+  VLOG(1) << "done FindGenerators found " << generators->size()
+          << " in " << (base::Time::Now() - start_find_time).InSecondsF()
+          << "s";
 
   return C_OK;
 }
 
 void FreeGenerators(std::vector<TransformationPatchGenerator*>* generators) {
   for (size_t i = 0;  i < generators->size();  ++i) {
     delete (*generators)[i];
   }
   generators->clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 Status GenerateEnsemblePatch(SourceStream* base,
                              SourceStream* update,
                              SinkStream* final_patch) {
-  LOG(INFO) << "start GenerateEnsemblePatch";
+  VLOG(1) << "start GenerateEnsemblePatch";
   base::Time start_time = base::Time::Now();
 
   Region old_region(base->Buffer(), base->Remaining());
   Region new_region(update->Buffer(), update->Remaining());
   Ensemble old_ensemble(old_region, "old");
   Ensemble new_ensemble(new_region, "new");
   std::vector<TransformationPatchGenerator*> generators;
   Status generators_status = FindGenerators(&old_ensemble, &new_ensemble,
                                             &generators);
   if (generators_status != C_OK)
@@ skipping 172 matching lines @@
   final_patch->WriteVarint32(CourgettePatchFile::kVersion);
 
   final_patch->WriteVarint32(
       CalculateCrc(old_region.start(), old_region.length()));
   final_patch->WriteVarint32(
       CalculateCrc(new_region.start(), new_region.length()));
 
   if (!patch_streams.CopyTo(final_patch))
     return C_STREAM_ERROR;
 
-  LOG(INFO) << "done GenerateEnsemblePatch "
-            << (base::Time::Now() - start_time).InSecondsF() << "s";
+  VLOG(1) << "done GenerateEnsemblePatch "
+          << (base::Time::Now() - start_time).InSecondsF() << "s";
 
   return C_OK;
 }
 
 }  // namespace