Fix feedback log collection.

chrome/common/metrics/metrics_log_manager.cc

 // Copyright (c) 2012 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 "chrome/common/metrics/metrics_log_manager.h"
 
-#if defined(USE_SYSTEM_LIBBZ2)
-#include <bzlib.h>
-#else
-#include "third_party/bzip2/bzlib.h"
-#endif
-
 #include <algorithm>
 
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
+#include "base/strings/string_compress.h"
 #include "chrome/common/metrics/metrics_log_base.h"
 
 namespace {
 
 // Used to keep track of discarded protobuf logs without having to track xml and
 // protobuf logs in separate lists.
 const char kDiscardedLog[] = "Log discarded";
 
 }  // anonymous namespace
 
@@ skipping 199 matching lines @@
   log_serializer_->DeserializeLogs(ONGOING_LOG, &unsent_ongoing_logs_);
 }
 
 void MetricsLogManager::CompressCurrentLog(SerializedLog* compressed_log) {
   int text_size = current_log_->GetEncodedLogSizeXml();
   DCHECK_GT(text_size, 0);
   std::string log_text;
   current_log_->GetEncodedLogXml(WriteInto(&log_text, text_size + 1),
                                  text_size);
 
-  bool success = Bzip2Compress(log_text, &(compressed_log->xml));
+  bool success = base::Bzip2Compress(log_text, &(compressed_log->xml));
   if (success) {
     // Allow security-conscious users to see all metrics logs that we send.
     DVLOG(1) << "METRICS LOG: " << log_text;
 
     // Note that we only save the protobuf version if we succeeded in
     // compressing the XML, so that the two data streams are the same.
     current_log_->GetEncodedLogProto(&(compressed_log->proto));
   } else {
     NOTREACHED() << "Failed to compress log for transmission.";
   }
 }
-
-// static
-// This implementation is based on the Firefox MetricsService implementation.
-bool MetricsLogManager::Bzip2Compress(const std::string& input,
-                                      std::string* output) {
-  bz_stream stream = {0};
-  // As long as our input is smaller than the bzip2 block size, we should get
-  // the best compression.  For example, if your input was 250k, using a block
-  // size of 300k or 500k should result in the same compression ratio.  Since
-  // our data should be under 100k, using the minimum block size of 100k should
-  // allocate less temporary memory, but result in the same compression ratio.
-  int result = BZ2_bzCompressInit(&stream,
-                                  1,   // 100k (min) block size
-                                  0,   // quiet
-                                  0);  // default "work factor"
-  if (result != BZ_OK) {  // out of memory?
-    return false;
-  }
-
-  output->clear();
-
-  stream.next_in = const_cast<char*>(input.data());
-  stream.avail_in = static_cast<int>(input.size());
-  // NOTE: we don't need a BZ_RUN phase since our input buffer contains
-  //       the entire input
-  do {
-    output->resize(output->size() + 1024);
-    stream.next_out = &((*output)[stream.total_out_lo32]);
-    stream.avail_out = static_cast<int>(output->size()) - stream.total_out_lo32;
-    result = BZ2_bzCompress(&stream, BZ_FINISH);
-  } while (result == BZ_FINISH_OK);
-  if (result != BZ_STREAM_END) {  // unknown failure?
-    output->clear();
-    // TODO(jar): See if it would be better to do a CHECK() here.
-    return false;
-  }
-  result = BZ2_bzCompressEnd(&stream);
-  DCHECK(result == BZ_OK);
-
-  output->resize(stream.total_out_lo32);
-
-  return true;
-}