Update brotli to v1.0.0-snapshot.

net/filter/brotli_source_stream.cc

 // Copyright 2016 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 "net/filter/brotli_source_stream.h"
 
 #include "base/bind.h"
 #include "base/bit_cast.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "net/base/io_buffer.h"
-#include "third_party/brotli/dec/decode.h"
+#include "third_party/brotli/include/brotli/decode.h"
 
 namespace net {
 
 namespace {
 
 const char kBrotli[] = "BROTLI";
 const uint8_t kGzipHeader[] = {0x1f, 0x8b, 0x08};
 
 // BrotliSourceStream applies Brotli content decoding to a data stream.
 // Brotli format specification: http://www.ietf.org/id/draft-alakuijala-brotli.
 class BrotliSourceStream : public FilterSourceStream {
  public:
   explicit BrotliSourceStream(std::unique_ptr<SourceStream> upstream)
       : FilterSourceStream(SourceStream::TYPE_BROTLI, std::move(upstream)),
         decoding_status_(DecodingStatus::DECODING_IN_PROGRESS),
         used_memory_(0),
         used_memory_maximum_(0),
         consumed_bytes_(0),
         produced_bytes_(0),
         gzip_header_detected_(true) {
-    brotli_state_ = BrotliCreateState(AllocateMemory, FreeMemory, this);
+    brotli_state_ =
+        BrotliDecoderCreateInstance(AllocateMemory, FreeMemory, this);
     CHECK(brotli_state_);
   }
 
   ~BrotliSourceStream() override {
-    BrotliErrorCode error_code = BrotliGetErrorCode(brotli_state_);
-    BrotliDestroyState(brotli_state_);
+    BrotliDecoderErrorCode error_code =
+        BrotliDecoderGetErrorCode(brotli_state_);
+    BrotliDecoderDestroyInstance(brotli_state_);
     brotli_state_ = nullptr;
     DCHECK_EQ(0u, used_memory_);
 
     // Don't report that gzip header was detected in case of lack of input.
     gzip_header_detected_ &= (consumed_bytes_ >= sizeof(kGzipHeader));
 
     UMA_HISTOGRAM_ENUMERATION(
         "BrotliFilter.Status", static_cast<int>(decoding_status_),
         static_cast<int>(DecodingStatus::DECODING_STATUS_COUNT));
     UMA_HISTOGRAM_BOOLEAN("BrotliFilter.GzipHeaderDetected",
@@ skipping 46 matching lines @@
       return OK;
     }
 
     if (decoding_status_ != DecodingStatus::DECODING_IN_PROGRESS)
       return ERR_CONTENT_DECODING_FAILED;
 
     const uint8_t* next_in = bit_cast<uint8_t*>(input_buffer->data());
     size_t available_in = input_buffer_size;
     uint8_t* next_out = bit_cast<uint8_t*>(output_buffer->data());
     size_t available_out = output_buffer_size;
-    size_t total_out = 0;
     // Check if start of the input stream looks like gzip stream.
     for (size_t i = consumed_bytes_; i < sizeof(kGzipHeader); ++i) {
       if (!gzip_header_detected_)
         break;
       size_t j = i - consumed_bytes_;
       if (j < available_in && kGzipHeader[i] != next_in[j])
         gzip_header_detected_ = false;
     }
 
-    BrotliResult result =
-        BrotliDecompressStream(&available_in, &next_in, &available_out,
-                               &next_out, &total_out, brotli_state_);
+    BrotliDecoderResult result =
+        BrotliDecoderDecompressStream(brotli_state_, &available_in, &next_in,
+                                      &available_out, &next_out, nullptr);
 
     size_t bytes_used = input_buffer_size - available_in;
     size_t bytes_written = output_buffer_size - available_out;
     CHECK_GE(bytes_used, 0u);
     CHECK_GE(bytes_written, 0u);
     produced_bytes_ += bytes_written;
     consumed_bytes_ += bytes_used;
 
     *consumed_bytes = bytes_used;
 
     switch (result) {
-      case BROTLI_RESULT_NEEDS_MORE_OUTPUT:
+      case BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT:
         return bytes_written;
-      case BROTLI_RESULT_SUCCESS:
+      case BROTLI_DECODER_RESULT_SUCCESS:
         decoding_status_ = DecodingStatus::DECODING_DONE;
         // Consume remaining bytes to avoid DCHECK in FilterSourceStream.
         // See crbug.com/659311.
         *consumed_bytes = input_buffer_size;
         return bytes_written;
-      case BROTLI_RESULT_NEEDS_MORE_INPUT:
+      case BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT:
         // Decompress needs more input has consumed all existing input.
         DCHECK_EQ(*consumed_bytes, input_buffer_size);
         decoding_status_ = DecodingStatus::DECODING_IN_PROGRESS;
         return bytes_written;
       // If the decompressor threw an error, fail synchronously.
       default:
         decoding_status_ = DecodingStatus::DECODING_ERROR;
         return ERR_CONTENT_DECODING_FAILED;
     }
   }
@@ skipping 20 matching lines @@
   }
 
   void FreeMemoryInternal(void* address) {
     if (!address)
       return;
     size_t* array = reinterpret_cast<size_t*>(address);
     used_memory_ -= array[-1];
     free(&array[-1]);
   }
 
-  BrotliState* brotli_state_;
+  BrotliDecoderState* brotli_state_;
 
   DecodingStatus decoding_status_;
 
   size_t used_memory_;
   size_t used_memory_maximum_;
   size_t consumed_bytes_;
   size_t produced_bytes_;
 
   bool gzip_header_detected_;
 
   DISALLOW_COPY_AND_ASSIGN(BrotliSourceStream);
 };
 
 }  // namespace
 
 std::unique_ptr<FilterSourceStream> CreateBrotliSourceStream(
     std::unique_ptr<SourceStream> previous) {
   return base::WrapUnique(new BrotliSourceStream(std::move(previous)));
 }
 
 }  // namespace net