Remove obsolete methods from nanopb::Writer

Author: rsgowman

Firestore/core/src/firebase/firestore/nanopb/writer.cc

@@ -16,17 +16,12 @@
 
 #include "Firestore/core/src/firebase/firestore/nanopb/writer.h"
 
-#include "Firestore/Protos/nanopb/google/firestore/v1beta1/document.nanopb.h"
 #include "Firestore/core/src/firebase/firestore/util/hard_assert.h"
 
 namespace firebase {
 namespace firestore {
 namespace nanopb {
 
-using std::int64_t;
-using std::int8_t;
-using std::uint64_t;
-
 namespace {
 
 // TODO(rsgowman): find a better home for this constant.
@@ -66,111 +61,21 @@ pb_ostream_t WrapContainer(Container* out_container) {
 
 }  // namespace
 
-Writer Writer::Wrap(std::vector<uint8_t>* out_bytes) {
+Writer Writer::Wrap(std::vector<std::uint8_t>* out_bytes) {
   return Writer{WrapContainer(out_bytes)};
 }
 
 Writer Writer::Wrap(std::string* out_string) {
   return Writer{WrapContainer(out_string)};
 }
 
-void Writer::WriteTag(Tag tag) {
-  if (!pb_encode_tag(&stream_, tag.wire_type, tag.field_number)) {
-    HARD_FAIL(PB_GET_ERROR(&stream_));
-  }
-}
-
 void Writer::WriteNanopbMessage(const pb_field_t fields[],
                                 const void* src_struct) {
   if (!pb_encode(&stream_, fields, src_struct)) {
     HARD_FAIL(PB_GET_ERROR(&stream_));
   }
 }
 
-void Writer::WriteSize(size_t size) {
-  return WriteVarint(size);
-}
-
-void Writer::WriteVarint(uint64_t value) {
-  if (!pb_encode_varint(&stream_, value)) {
-    HARD_FAIL(PB_GET_ERROR(&stream_));
-  }
-}
-
-void Writer::WriteNull() {
-  return WriteVarint(google_protobuf_NullValue_NULL_VALUE);
-}
-
-void Writer::WriteBool(bool bool_value) {
-  return WriteVarint(bool_value);
-}
-
-void Writer::WriteInteger(int64_t integer_value) {
-  return WriteVarint(integer_value);
-}
-
-void Writer::WriteString(const std::string& string_value) {
-  if (!pb_encode_string(
-          &stream_, reinterpret_cast<const pb_byte_t*>(string_value.c_str()),
-          string_value.length())) {
-    HARD_FAIL(PB_GET_ERROR(&stream_));
-  }
-}
-
-void Writer::WriteBytes(const std::vector<uint8_t>& bytes) {
-  if (!pb_encode_string(&stream_,
-                        reinterpret_cast<const pb_byte_t*>(bytes.data()),
-                        bytes.size())) {
-    HARD_FAIL(PB_GET_ERROR(&stream_));
-  }
-}
-
-void Writer::WriteNestedMessage(
-    const std::function<void(Writer*)>& write_message_fn) {
-  // First calculate the message size using a non-writing substream.
-  Writer sizer = Writer::Sizing();
-  write_message_fn(&sizer);
-  size_t size = sizer.bytes_written();
-
-  // Write out the size to the output writer.
-  WriteSize(size);
-
-  // If this stream is itself a sizing stream, then we don't need to actually
-  // parse field_value a second time; just update the bytes_written via a call
-  // to pb_write. (If we try to write the contents into a sizing stream, it'll
-  // fail since sizing streams don't actually have any buffer space.)
-  if (stream_.callback == nullptr) {
-    if (!pb_write(&stream_, nullptr, size)) {
-      HARD_FAIL(PB_GET_ERROR(&stream_));
-    }
-    return;
-  }
-
-  // Ensure the output stream has enough space
-  if (stream_.bytes_written + size > stream_.max_size) {
-    HARD_FAIL(
-        "Insufficient space in the output stream to write the given message");
-  }
-
-  // Use a substream to verify that a callback doesn't write more than what it
-  // did the first time. (Use an initializer rather than setting fields
-  // individually like nanopb does. This gives us a *chance* of noticing if
-  // nanopb adds new fields.)
-  Writer writer({stream_.callback, stream_.state,
-                 /*max_size=*/size, /*bytes_written=*/0,
-                 /*errmsg=*/nullptr});
-  write_message_fn(&writer);
-
-  stream_.bytes_written += writer.stream_.bytes_written;
-  stream_.state = writer.stream_.state;
-  stream_.errmsg = writer.stream_.errmsg;
-
-  if (writer.bytes_written() != size) {
-    // submsg size changed
-    HARD_FAIL("Parsing the nested message twice yielded different sizes");
-  }
-}
-
 }  // namespace nanopb
 }  // namespace firestore
 }  // namespace firebase

Firestore/core/src/firebase/firestore/nanopb/writer.h

@@ -21,12 +21,9 @@
 #include <pb_encode.h>
 
 #include <cstdint>
-#include <functional>
 #include <string>
 #include <vector>
 
-#include "Firestore/core/src/firebase/firestore/nanopb/tag.h"
-
 namespace firebase {
 namespace firestore {
 namespace nanopb {
@@ -59,21 +56,6 @@ class Writer {
    */
   static Writer Wrap(std::string* out_string);
 
-  /**
-   * Creates a non-writing output stream used to calculate the size of
-   * the serialized output.
-   */
-  static Writer Sizing() {
-    return Writer(PB_OSTREAM_SIZING);
-  }
-
-  /**
-   * Writes a message type to the output stream.
-   *
-   * This essentially wraps calls to nanopb's pb_encode_tag() method.
-   */
-  void WriteTag(Tag tag);
-
   /**
    * Writes a nanopb message to the output stream.
    *
@@ -83,34 +65,6 @@ class Writer {
    */
   void WriteNanopbMessage(const pb_field_t fields[], const void* src_struct);
 
-  void WriteSize(size_t size);
-  void WriteNull();
-  void WriteBool(bool bool_value);
-  void WriteInteger(std::int64_t integer_value);
-
-  void WriteString(const std::string& string_value);
-  void WriteBytes(const std::vector<uint8_t>& bytes);
-
-  /**
-   * Writes a message and its length.
-   *
-   * When writing a top level message, protobuf doesn't include the length
-   * (since you can get that already from the length of the binary output.) But
-   * when writing a sub/nested message, you must include the length in the
-   * serialization.
-   *
-   * Call this method when writing a nested message. Provide a function to
-   * write the message itself. This method will calculate the size of the
-   * written message (using the provided function with a non-writing sizing
-   * stream), write out the size (and perform sanity checks), and then serialize
-   * the message by calling the provided function a second time.
-   */
-  void WriteNestedMessage(const std::function<void(Writer*)>& write_message_fn);
-
-  size_t bytes_written() const {
-    return stream_.bytes_written;
-  }
-
  private:
   /**
    * Creates a new Writer, based on the given nanopb pb_ostream_t. Note that
@@ -120,21 +74,6 @@ class Writer {
   explicit Writer(const pb_ostream_t& stream) : stream_(stream) {
   }
 
-  /**
-   * Writes a "varint" to the output stream.
-   *
-   * This essentially wraps calls to nanopb's pb_encode_varint() method.
-   *
-   * Note that (despite the value parameter type) this works for bool, enum,
-   * int32, int64, uint32 and uint64 proto field types.
-   *
-   * Note: This is not expected to be called directly, but rather only
-   * via the other Write* methods (i.e. WriteBool, WriteLong, etc)
-   *
-   * @param value The value to write, represented as a uint64_t.
-   */
-  void WriteVarint(std::uint64_t value);
-
   pb_ostream_t stream_;
 };