Pull cacheinvalidations code directory into chromium repo.

third_party/cacheinvalidation/src/google/cacheinvalidation/impl/proto-helpers.cc

+// Copyright 2012 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Useful utility functions for the TICL
+
+#include "google/cacheinvalidation/impl/proto-helpers.h"
+
+#include <sstream>
+
+#include "google/cacheinvalidation/client_test_internal.pb.h"
+#include "google/cacheinvalidation/deps/string_util.h"
+
+namespace invalidation {
+
+using ::ipc::invalidation::RegistrationManagerStateP;
+
+// Defines a ToString template method specialization for the given type.
+#define DEFINE_TO_STRING(type)                                          \
+  template<>                                                            \
+  string ProtoHelpers::ToString(const type& message)
+
+// Creates a stringstream |stream| and emits a leading "{ " to it.
+#define BEGIN()                                 \
+  std::stringstream stream;                     \
+  stream << "{ "
+
+// Emits a closing " }" on |stream| and returns the string that has been built.
+#define END()                                   \
+  stream << " }";                               \
+  return stream.str()
+
+// Defines a trivial ToString method for a type (which just returns "<type>").
+#define DEFINE_TRIVIAL_TO_STRING(type)                                  \
+  DEFINE_TO_STRING(type) {                                              \
+    return "<" #type ">";                                               \
+  }
+
+// Emits "field: <field value as string>" if |field| is present in |message|.
+#define OPTIONAL(field)                                                 \
+  if (message.has_##field()) {                                          \
+    stream << #field << ": " << ToString(message.field()) << " ";       \
+  }
+
+// Emits "field: <field value as string>" for each instance of field in message.
+#define REPEATED(field)                                                 \
+  for (int i = 0; i < message.field##_size(); ++i) {                    \
+    stream << #field << ": " << ToString(message.field(i)) << " ";      \
+  }
+
+// Expands to a case branch that returns "name" if the implicitly tested
+// expression is equal to the enum constant |name| in the given |type|.
+#define ENUM_VALUE(type, name) case type##_##name: return #name
+
+// Expands to a default case branch that returns the string representation of
+// |message|.
+#define ENUM_UNKNOWN() default: return SimpleItoa(message)
+
+DEFINE_TO_STRING(bool) {
+  return message ? "true" : "false";
+}
+
+DEFINE_TO_STRING(int) {
+  std::stringstream stream;
+  stream << message;
+  return stream.str();
+}
+
+DEFINE_TO_STRING(int64) {
+  std::stringstream stream;
+  stream << message;
+  return stream.str();
+}
+
+/*
+ * Three arrays that store the representation of each character from 0 to 255.
+ * The ith number's octal representation is: CHAR_OCTAL_STRINGS1[i],
+ * CHAR_OCTAL_STRINGS2[i], CHAR_OCTAL_STRINGS3[i]
+ * <p>
+ * E.g., if the number 128, these arrays contain 2, 0, 0 at index 128. We use
+ * 3 char arrays instead of an array of strings since the code path for a
+ * character append operation is quite a bit shorterthan the append operation
+ * for strings.
+ */
+char ProtoHelpers::CHAR_OCTAL_STRINGS1[];
+char ProtoHelpers::CHAR_OCTAL_STRINGS2[];
+char ProtoHelpers::CHAR_OCTAL_STRINGS3[];
+bool ProtoHelpers::is_initialized = false;
+
+template<>
+string ProtoHelpers::ToString(const string& bytes) {
+  // This is a racy initialization but that is ok since we are initializing to
+  // the same values.
+  if (!is_initialized) {
+    // Initialize the array with the Octal string values so that we do not have
+    //  to do string.format for every byte during runtime.
+    for (int i = 0; i < ProtoHelpers::NUM_CHARS; i++) {
+      string value = StringPrintf("%03o", i);
+      ProtoHelpers::CHAR_OCTAL_STRINGS1[i] = value[0];
+      ProtoHelpers::CHAR_OCTAL_STRINGS2[i] = value[1];
+      ProtoHelpers::CHAR_OCTAL_STRINGS3[i] = value[2];
+    }
+    is_initialized = true;
+  }
+  string builder;
+  builder.reserve(3 * bytes.length() + 2);
+  builder += "\"";
+  for (size_t i = 0; i < bytes.length(); i++) {
+    char c = bytes[i];
+    switch (c) {
+      case '\n': builder += '\\'; builder += 'n'; break;
+      case '\r': builder += '\\'; builder += 'r'; break;
+      case '\t': builder += '\\'; builder += 't'; break;
+      case '\"': builder += '\\'; builder += '"'; break;
+      case '\\': builder += '\\'; builder += '\\'; break;
+      default:
+        if ((c >= 32) && (c < 127) && c != '\'') {
+          builder += c;
+        } else {
+          int byteValue = c;
+          if (c < 0) {
+            byteValue = c + 256;
+          }
+          builder += '\\';
+          builder += CHAR_OCTAL_STRINGS1[byteValue];
+          builder += CHAR_OCTAL_STRINGS2[byteValue];
+          builder += CHAR_OCTAL_STRINGS3[byteValue];
+        }
+        break;
+    }
+  }
+  builder += "\"";
+  return builder;
+}
+
+void ProtoHelpers::InitRegistrationP(const ObjectIdP& oid,
+    RegistrationP::OpType op_type, RegistrationP* reg) {
+  reg->mutable_object_id()->CopyFrom(oid);
+  reg->set_op_type(op_type);
+}
+
+void ProtoHelpers::InitRateLimitP(int window_ms, int count,
+    RateLimitP *rate_limit) {
+  rate_limit->set_window_ms(window_ms);
+  rate_limit->set_count(count);
+}
+
+void ProtoHelpers::InitInitializeMessage(
+    const ApplicationClientIdP& application_client_id, const string& nonce,
+    InitializeMessage* init_msg) {
+  init_msg->set_client_type(application_client_id.client_type());
+  init_msg->mutable_application_client_id()->CopyFrom(
+      application_client_id);
+  init_msg->set_nonce(nonce);
+  init_msg->set_digest_serialization_type(
+      InitializeMessage_DigestSerializationType_BYTE_BASED);
+}
+
+void ProtoHelpers::InitClientVersion(const string& platform,
+    const string& application_info, ClientVersion* client_version) {
+  Version* version = client_version->mutable_version();
+  version->set_major_version(Constants::kClientMajorVersion);
+  version->set_minor_version(Constants::kClientMinorVersion);
+  client_version->set_platform(platform);
+  client_version->set_language("C++");
+  client_version->set_application_info(application_info);
+}
+
+void ProtoHelpers::InitProtocolVersion(ProtocolVersion* protocol_version) {
+  Version* version = protocol_version->mutable_version();
+  version->set_major_version(Constants::kProtocolMajorVersion);
+  version->set_minor_version(Constants::kProtocolMinorVersion);
+}
+
+void ProtoHelpers::InitConfigVersion(Version* config_version) {
+  config_version->set_major_version(Constants::kConfigMajorVersion);
+  config_version->set_minor_version(Constants::kConfigMinorVersion);
+}
+
+DEFINE_TO_STRING(ErrorMessage::Code) {
+  switch (message) {
+    ENUM_VALUE(ErrorMessage_Code, AUTH_FAILURE);
+    ENUM_VALUE(ErrorMessage_Code, UNKNOWN_FAILURE);
+    ENUM_UNKNOWN();
+  }
+}
+DEFINE_TO_STRING(InfoRequestMessage::InfoType) {
+  switch (message) {
+    ENUM_VALUE(InfoRequestMessage_InfoType, GET_PERFORMANCE_COUNTERS);
+    ENUM_UNKNOWN();
+  }
+}
+
+DEFINE_TO_STRING(InitializeMessage::DigestSerializationType) {
+  switch (message) {
+    ENUM_VALUE(InitializeMessage_DigestSerializationType, BYTE_BASED);
+    ENUM_VALUE(InitializeMessage_DigestSerializationType, NUMBER_BASED);
+    ENUM_UNKNOWN();
+  }
+}
+
+DEFINE_TO_STRING(StatusP::Code) {
+  switch (message) {
+    ENUM_VALUE(StatusP_Code, SUCCESS);
+    ENUM_VALUE(StatusP_Code, TRANSIENT_FAILURE);
+    ENUM_VALUE(StatusP_Code, PERMANENT_FAILURE);
+    ENUM_UNKNOWN();
+  }
+}
+
+DEFINE_TO_STRING(RegistrationP::OpType) {
+  switch (message) {
+    ENUM_VALUE(RegistrationP_OpType, REGISTER);
+    ENUM_VALUE(RegistrationP_OpType, UNREGISTER);
+    ENUM_UNKNOWN();
+  }
+}
+
+DEFINE_TO_STRING(RegistrationSyncRequestMessage) {
+  BEGIN();
+  END();
+}
+
+DEFINE_TO_STRING(Version) {
+  BEGIN();
+  OPTIONAL(major_version);
+  OPTIONAL(minor_version);
+  END();
+}
+
+DEFINE_TO_STRING(ClientVersion) {
+  BEGIN();
+  OPTIONAL(version);
+  OPTIONAL(platform);
+  OPTIONAL(language);
+  OPTIONAL(application_info);
+  END();
+}
+
+DEFINE_TO_STRING(ProtocolVersion) {
+  BEGIN();
+  OPTIONAL(version);
+  END();
+}
+
+DEFINE_TO_STRING(InfoRequestMessage) {
+  BEGIN();
+  REPEATED(info_type);
+  END();
+}
+
+DEFINE_TO_STRING(ConfigChangeMessage) {
+  BEGIN();
+  OPTIONAL(next_message_delay_ms);
+  END();
+}
+
+DEFINE_TO_STRING(PropertyRecord) {
+  BEGIN();
+  OPTIONAL(name);
+  OPTIONAL(value);
+  END();
+}
+
+DEFINE_TO_STRING(RateLimitP) {
+  BEGIN();
+  OPTIONAL(window_ms);
+  OPTIONAL(count);
+  END();
+}
+
+DEFINE_TO_STRING(ProtocolHandlerConfigP) {
+  BEGIN();
+  OPTIONAL(batching_delay_ms);
+  REPEATED(rate_limit);
+  END();
+}
+
+DEFINE_TO_STRING(ClientConfigP) {
+  BEGIN();
+  OPTIONAL(version);
+  OPTIONAL(network_timeout_delay_ms);
+  OPTIONAL(write_retry_delay_ms);
+  OPTIONAL(heartbeat_interval_ms);
+  OPTIONAL(perf_counter_delay_ms);
+  OPTIONAL(max_exponential_backoff_factor);
+  OPTIONAL(smear_percent);
+  OPTIONAL(is_transient);
+  OPTIONAL(initial_persistent_heartbeat_delay_ms);
+  OPTIONAL(protocol_handler_config);
+  END();
+}
+
+DEFINE_TO_STRING(InfoMessage) {
+  BEGIN();
+  OPTIONAL(client_version);
+  REPEATED(config_parameter);
+  REPEATED(performance_counter);
+  OPTIONAL(server_registration_summary_requested);
+  END();
+}
+
+DEFINE_TO_STRING(ErrorMessage) {
+  BEGIN();
+  OPTIONAL(code);
+  OPTIONAL(description);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationSummary) {
+  BEGIN();
+  OPTIONAL(num_registrations);
+  OPTIONAL(registration_digest);
+  END();
+}
+
+DEFINE_TO_STRING(ObjectIdP) {
+  BEGIN();
+  OPTIONAL(source);
+  OPTIONAL(name);
+  END();
+}
+
+DEFINE_TO_STRING(InvalidationP) {
+  BEGIN();
+  OPTIONAL(object_id);
+  OPTIONAL(is_known_version);
+  OPTIONAL(version);
+  OPTIONAL(is_trickle_restart);
+  OPTIONAL(payload);
+  END();
+}
+
+DEFINE_TO_STRING(AckHandleP) {
+  BEGIN();
+  OPTIONAL(invalidation);
+  END();
+}
+
+DEFINE_TO_STRING(ApplicationClientIdP) {
+  BEGIN();
+  OPTIONAL(client_type);
+  OPTIONAL(client_name);
+  END();
+}
+
+DEFINE_TO_STRING(StatusP) {
+  BEGIN();
+  OPTIONAL(code);
+  OPTIONAL(description);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationP) {
+  BEGIN();
+  OPTIONAL(object_id);
+  OPTIONAL(op_type);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationStatus) {
+  BEGIN();
+  OPTIONAL(registration);
+  OPTIONAL(status);
+  END();
+}
+
+DEFINE_TO_STRING(ClientHeader) {
+  BEGIN();
+  OPTIONAL(protocol_version);
+  OPTIONAL(client_token);
+  OPTIONAL(registration_summary);
+  OPTIONAL(client_time_ms);
+  OPTIONAL(max_known_server_time_ms);
+  OPTIONAL(message_id);
+  END();
+}
+
+DEFINE_TO_STRING(InitializeMessage) {
+  BEGIN();
+  OPTIONAL(client_type);
+  OPTIONAL(nonce);
+  OPTIONAL(application_client_id);
+  OPTIONAL(digest_serialization_type);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationMessage) {
+  BEGIN();
+  REPEATED(registration);
+  END();
+}
+
+DEFINE_TO_STRING(InvalidationMessage) {
+  BEGIN();
+  REPEATED(invalidation);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationSubtree) {
+  BEGIN();
+  REPEATED(registered_object);
+  END();
+}
+DEFINE_TO_STRING(RegistrationSyncMessage) {
+  BEGIN();
+  REPEATED(subtree);
+  END();
+}
+
+DEFINE_TO_STRING(ClientToServerMessage) {
+  BEGIN();
+  OPTIONAL(header);
+  OPTIONAL(initialize_message);
+  OPTIONAL(registration_message);
+  OPTIONAL(registration_sync_message);
+  OPTIONAL(invalidation_ack_message);
+  OPTIONAL(info_message);
+  END();
+}
+
+DEFINE_TO_STRING(ServerHeader) {
+  BEGIN();
+  OPTIONAL(protocol_version);
+  OPTIONAL(client_token);
+  OPTIONAL(registration_summary);
+  OPTIONAL(server_time_ms);
+  OPTIONAL(message_id);
+  END();
+}
+
+DEFINE_TO_STRING(TokenControlMessage) {
+  BEGIN();
+  OPTIONAL(new_token);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationStatusMessage) {
+  BEGIN();
+  REPEATED(registration_status);
+  END();
+}
+
+DEFINE_TO_STRING(ServerToClientMessage) {
+  BEGIN();
+  OPTIONAL(header);
+  OPTIONAL(token_control_message);
+  OPTIONAL(invalidation_message);
+  OPTIONAL(registration_status_message);
+  OPTIONAL(registration_sync_request_message);
+  OPTIONAL(info_request_message);
+  END();
+}
+
+DEFINE_TO_STRING(RegistrationManagerStateP) {
+  BEGIN();
+  OPTIONAL(client_summary);
+  OPTIONAL(server_summary);
+  REPEATED(registered_objects);
+  END();
+}
+
+}  // namespace invalidation