Add LazySyncableAdapter

blimp/helium/lazy_syncable_adapter.h

+// 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.
+
+#ifndef BLIMP_HELIUM_LAZY_SYNCABLE_ADAPTER_H_
+#define BLIMP_HELIUM_LAZY_SYNCABLE_ADAPTER_H_
+
+#include <string>
+
+#include "base/memory/ptr_util.h"
+#include "blimp/helium/blimp_helium_export.h"
+#include "blimp/helium/syncable.h"
+#include "third_party/protobuf/src/google/protobuf/io/coded_stream.h"
+#include "third_party/protobuf/src/google/protobuf/io/zero_copy_stream_impl_lite.h"
+
+namespace blimp {
+namespace helium {
+
+namespace {
+template <class ChangesetType>
+std::unique_ptr<ChangesetType> ParseChangesetFromString(

[Kevin M, 2016/12/02 18:28:03]

Anonymous namespaced functions in the .h aren't actually hidden from anything.
They only really make sense in the .cc.

A static class private method makes more sense here.

[steimel, 2016/12/03 00:29:41]

Good point. Done.

+    const std::string& changeset) {
+  google::protobuf::io::ArrayInputStream raw_input_stream(changeset.data(),
+                                                          changeset.size());
+  google::protobuf::io::CodedInputStream input_stream(&raw_input_stream);
+  std::unique_ptr<ChangesetType> parsed_changeset =
+      base::MakeUnique<ChangesetType>();
+  parsed_changeset->Parse(&input_stream);
+  return parsed_changeset;
+}
+}  // namespace
+
+// The LazySyncableAdapter is used to wrap LazySyncables of any changeset type
+// into a LazySyncable with a string changeset by serializing the changesets
+// into a string and parsing them from strings. That way, ObjectSyncState can
+// just work with LazySyncables of type string.
+template <class ChangesetType>
+class BLIMP_HELIUM_EXPORT LazySyncableAdapter
+    : public LazySyncable<std::string> {
+ public:
+  explicit LazySyncableAdapter(LazySyncable<ChangesetType>* inner_syncable)
+      : inner_syncable_(inner_syncable) {}
+  ~LazySyncableAdapter() = default;
+
+  // LazySyncable implementation.
+  std::unique_ptr<std::string> CreateChangeset(Revision from) const override;
+  void ApplyChangeset(const std::string& changeset) override;
+  bool ValidateChangeset(const std::string& changeset) const override;
+  void SetLocalUpdateCallback(
+      const base::Closure& local_update_callback) override;
+  void ReleaseBefore(Revision before) override;
+  Revision GetRevision() const override;
+  void PrepareToCreateChangeset(Revision from, base::Closure done) override;
+
+ private:
+  LazySyncable<ChangesetType>* inner_syncable_;
+
+  DISALLOW_COPY_AND_ASSIGN(LazySyncableAdapter);
+};
+
+template <class ChangesetType>
+std::unique_ptr<std::string>
+LazySyncableAdapter<ChangesetType>::CreateChangeset(Revision from) const {
+  std::unique_ptr<ChangesetType> changeset =
+      inner_syncable_->CreateChangeset(from);
+  std::unique_ptr<std::string> output = base::MakeUnique<std::string>();
+  google::protobuf::io::StringOutputStream raw_output_stream(output.get());
+  google::protobuf::io::CodedOutputStream output_stream(&raw_output_stream);
+  changeset->Serialize(&output_stream);
+  return output;
+}
+
+template <class ChangesetType>
+void LazySyncableAdapter<ChangesetType>::ApplyChangeset(
+    const std::string& changeset) {
+  std::unique_ptr<ChangesetType> parsed_changeset =
+      ParseChangesetFromString<ChangesetType>(changeset);
+  inner_syncable_->ApplyChangeset(*parsed_changeset);
+}
+
+template <class ChangesetType>
+bool LazySyncableAdapter<ChangesetType>::ValidateChangeset(
+    const std::string& changeset) const {
+  std::unique_ptr<ChangesetType> parsed_changeset =
+      ParseChangesetFromString<ChangesetType>(changeset);
+  return inner_syncable_->ValidateChangeset(*parsed_changeset);
+}
+
+template <class ChangesetType>
+void LazySyncableAdapter<ChangesetType>::SetLocalUpdateCallback(
+    const base::Closure& local_update_callback) {
+  inner_syncable_->SetLocalUpdateCallback(local_update_callback);
+}
+
+template <class ChangesetType>
+void LazySyncableAdapter<ChangesetType>::ReleaseBefore(Revision before) {
+  inner_syncable_->ReleaseBefore(before);
+}
+
+template <class ChangesetType>
+Revision LazySyncableAdapter<ChangesetType>::GetRevision() const {
+  return inner_syncable_->GetRevision();
+}
+
+template <class ChangesetType>
+void LazySyncableAdapter<ChangesetType>::PrepareToCreateChangeset(
+    Revision from,
+    base::Closure done) {
+  inner_syncable_->PrepareToCreateChangeset(from, done);
+}
+
+}  // namespace helium
+}  // namespace blimp
+#endif  // BLIMP_HELIUM_LAZY_SYNCABLE_ADAPTER_H_