Introduced ChunkedByteBuffer class which will be needed by next speech recognition CLs.

content/browser/speech/chunked_byte_buffer.h

Index: content/browser/speech/chunked_byte_buffer.h
diff --git a/content/browser/speech/chunked_byte_buffer.h b/content/browser/speech/chunked_byte_buffer.h
new file mode 100644
index 0000000000000000000000000000000000000000..694136514e35b9d963d1371f2477b6796ac9b1a8
--- /dev/null
+++ b/content/browser/speech/chunked_byte_buffer.h
@@ -0,0 +1,71 @@
+// 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.
+
+#ifndef CONTENT_BROWSER_SPEECH_CHUNKED_BYTE_BUFFER_H_
+#define CONTENT_BROWSER_SPEECH_CHUNKED_BYTE_BUFFER_H_
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+
+namespace speech {
+
+// Models a chunk-oriented byte buffer. The term chunk is herein defined as an
+// arbitrary sequence of bytes that is preceeded by a length field, indicating
+// its size. Data may be appended to the buffer with no particular respect of
+// chunks boundaries. However, chunks can be extracted (FIFO) only when their
+// content (according to length field) is fully available in the buffer.
+// The current implementation support only 4 byte Big Endian length fields.
+//
+// E.g. 00 00 00 04 xx xx xx xx 00 00 00 02 yy yy 00 00 00 04 zz zz zz zz
+//      [----- CHUNK 1 -------] [--- CHUNK 2 ---] [------ CHUNK 3 ------]
+class ChunkedByteBuffer {

[Satish, 2012/04/23 11:01:44]

A general comment about this class - you are inserting all data into a single
byte vector, readers read the first chunk & erase (which shifts remaining data
to the start) and so on. I think another way to do this would be to keep a
vector of chunks, i.e. vector<vector<byte>> and an 'in-progress' chunk
separately. Append will add content to the 'in-progress' chunk and once it
receives all data move it into the chunk vector. Get/Read methods will always
read the chunk vector so the in-progress chunk would be left out of it. I think
this way you have less memory copies and the GetNextChunk() method can return
the vector to the caller and remove it from this list instead of the current
ReadChunk & RemoveChunk methods

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Hmm I like it. it will increase a bit the complexity of this class (since no
assumption can be made on the granularity and boundaries of Append-ed data), but
I think it will be worth doing it.

+ public:
+  ChunkedByteBuffer();
+  ~ChunkedByteBuffer();
+
+  // Appends |length| bytes starting from |start| to the buffer.
+  void Append(const uint8* start, size_t length);
+
+  // Appends bytes contained into the |string| to the buffer.

[Satish, 2012/04/23 11:01:44]

into -> in

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Done.

+  void Append(const std::string& string);
+
+  // Returns whether a chunk is present in the buffer and can be extracted.
+  // In that case its length is copied into |chunk_length| pointer, if not NULL.
+  bool CanReadChunk(size_t* chunk_length) const;

[Satish, 2012/04/23 11:01:44]

perhaps simpler to combine these two methods into
  size_t GetNextChunkSize() const;
which returns 0 if there are no chunks and a non-zero value if there is data?

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

I originally adopted this pattern in order to contemplate the sequence 00 00 00
00 which leads into a 0 length chunk. However, I agree that it does not make a
lot of sense, so I "banned" the zero-length chunks and adopted the pattern you
suggested.

+
+  // Returns whether a chunk is present in the buffer and can be extracted.
+  // Equivalent to calling CanReadChunk(NULL).
+  bool CanReadChunk() const;
+
+  // If enough data is available, reads a chunk from the buffer, copying its
+  // boundaries into the |start_ptr| and |length| pointers (MUST be non NULL).
+  // The chunk is NOT removed from the buffer after this call.
+  // Return value has the same semantic of CanReadChunk.
+  bool ReadChunk(const uint8** start_ptr, size_t* length) const;

[Satish, 2012/04/23 11:01:44]

If you like the above idea, could rewrite this as
  size_t GetNextChunk(const uint8** start_ptr);

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Done.

+
+  // Shifts out the first chunk from the buffer.
+  // Fails (NOTREACHED) if there is not enough data for an entire chunk.

[Satish, 2012/04/23 11:01:44]

this is an implementation detail and shouldn't be mentioned here

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Done.

+  void RemoveChunk();
+
+  // Clears all the content of the buffer.
+  void Clear();
+
+  // Returns the number of raw bytes (including length fields) present.
+  size_t Size() const { return buffer_.size(); }

[Satish, 2012/04/23 11:01:44]

rename to GetSize() so the method name is the action it does than the value it
returns

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Renamed to GetTotalLength(), since it is more clear.

+
+ private:
+  static uint32 ReadBigEndian32(const uint8* buffer);
+  static const int kLengthFieldSize;

[Satish, 2012/04/23 11:01:44]

I'd prefer these two to be moved to the anonymous namespace of the .cc file as
they aren't accessing the methods/members  of this class at all

[Primiano Tucci (use gerrit), 2012/04/23 17:13:57]

Done.

+
+  std::vector<uint8> buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChunkedByteBuffer);
+};
+
+}  // namespace speech
+
+#endif  // CONTENT_BROWSER_SPEECH_CHUNKED_BYTE_BUFFER_H_