[update_engine] Update to use not-hideously-old logging API from chrome

delta_diff_generator.cc

 // Copyright (c) 2009 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 "update_engine/delta_diff_generator.h"
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <algorithm>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 #include <bzlib.h>
-#include "chromeos/obsolete_logging.h"
+#include "base/logging.h"
 #include "update_engine/bzip.h"
 #include "update_engine/cycle_breaker.h"
 #include "update_engine/extent_mapper.h"
 #include "update_engine/file_writer.h"
 #include "update_engine/filesystem_iterator.h"
 #include "update_engine/graph_types.h"
 #include "update_engine/graph_utils.h"
 #include "update_engine/subprocess.h"
 #include "update_engine/topological_sort.h"
 #include "update_engine/update_metadata.pb.h"
@@ skipping 618 matching lines @@
     graph->back().op.set_dst_length(graph->back().op.src_length());
 
     // make the dest node read from the scratch space
     DeltaDiffGenerator::SubstituteBlocks(
         &((*graph)[it->second].op),
         (*graph)[it->first].out_edges[it->second].extents,
         scratch);
 
     // delete the old edge
     CHECK_EQ(1, (*graph)[it->first].out_edges.erase(it->second));
-    
+
     // Add an edge from dst to copy operation
     (*graph)[it->second].out_edges.insert(make_pair(graph->size() - 1,
                                                     EdgeProperties()));
   }
   return true;
 }
 
 // Stores all Extents in 'extents' into 'out'.
 void DeltaDiffGenerator::StoreExtents(
     vector<Extent>& extents,
@@ skipping 19 matching lines @@
     if (blocks[i].reader == blocks[i].writer)
       continue;
     // See if there's already an edge we can add onto
     Vertex::EdgeMap::iterator edge_it =
         (*graph)[blocks[i].writer].out_edges.find(blocks[i].reader);
     if (edge_it == (*graph)[blocks[i].writer].out_edges.end()) {
       // No existing edge. Create one
       (*graph)[blocks[i].writer].out_edges.insert(
           make_pair(blocks[i].reader, EdgeProperties()));
       edge_it = (*graph)[blocks[i].writer].out_edges.find(blocks[i].reader);
-      CHECK_NE(edge_it, (*graph)[blocks[i].writer].out_edges.end());
+      CHECK(edge_it != (*graph)[blocks[i].writer].out_edges.end());
     }
     graph_utils::AppendBlockToExtents(&edge_it->second.extents, i);
   }
 }
 
 bool DeltaDiffGenerator::ReorderDataBlobs(
     DeltaArchiveManifest* manifest,
     const std::string& data_blobs_path,
     const std::string& new_data_blobs_path) {
   int in_fd = open(data_blobs_path.c_str(), O_RDONLY, 0);
   TEST_AND_RETURN_FALSE_ERRNO(in_fd >= 0);
   ScopedFdCloser in_fd_closer(&in_fd);
-  
+
   DirectFileWriter writer;
   TEST_AND_RETURN_FALSE(
       writer.Open(new_data_blobs_path.c_str(),
                   O_WRONLY | O_TRUNC | O_CREAT,
                   0644) == 0);
   ScopedFileWriterCloser writer_closer(&writer);
   uint64_t out_file_size = 0;
-  
+
   for (int i = 0; i < (manifest->install_operations_size() +
                        manifest->kernel_install_operations_size()); i++) {
     DeltaArchiveManifest_InstallOperation* op = NULL;
     if (i < manifest->install_operations_size()) {
       op = manifest->mutable_install_operations(i);
     } else {
       op = manifest->mutable_kernel_install_operations(
           i - manifest->install_operations_size());
     }
     if (!op->has_data_offset())
@@ skipping 215 matching lines @@
   
   LOG(INFO) << "All done. Successfully created delta file.";
   return true;
 }
 
 const char* const kBsdiffPath = "/usr/bin/bsdiff";
 const char* const kBspatchPath = "/usr/bin/bspatch";
 const char* const kDeltaMagic = "CrAU";
 
 };  // namespace chromeos_update_engine