[sync] Properly estimate EntryKernel memory usage.

components/sync/syncable/entry_kernel.cc

 // 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.
 
 #include "components/sync/syncable/entry_kernel.h"
 
 #include <utility>
 
 #include "base/json/string_escape.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 131 matching lines @@
 }
 
 base::Value* UniquePositionToValue(const UniquePosition& pos) {
   return new base::Value(pos.ToDebugString());
 }
 
 base::Value* AttachmentMetadataToValue(const sync_pb::AttachmentMetadata& a) {
   return new base::Value(a.SerializeAsString());
 }
 
+// Estimates memory usage of ProtoValuePtr<T> arrays where consecutive
+// elements can share the same value.
+template <class T, size_t N>
+size_t EstimateSharedMemoryUsage(ProtoValuePtr<T> const (&ptrs)[N]) {
+  size_t memory_usage = 0;
+  const T* last_value = nullptr;
+  for (const auto& ptr : ptrs) {
+    if (last_value != &ptr.value()) {
+      memory_usage += EstimateMemoryUsage(ptr);
+      last_value = &ptr.value();
+    }
+  }
+  return memory_usage;
+}
+
 }  // namespace
 
 base::DictionaryValue* EntryKernel::ToValue(
     Cryptographer* cryptographer) const {
   base::DictionaryValue* kernel_info = new base::DictionaryValue();
   kernel_info->SetBoolean("isDirty", is_dirty());
   ModelType dataType = GetServerModelType();
   if (!IsRealDataType(dataType))
     dataType = GetModelType();
   kernel_info->Set("modelType", ModelTypeToValue(dataType));
@@ skipping 47 matching lines @@
   SetFieldValues(*this, kernel_info, &GetBitTempString, &BooleanToValue,
                  BIT_TEMPS_BEGIN, BIT_TEMPS_END - 1);
 
   return kernel_info;
 }
 
 size_t EntryKernel::EstimateMemoryUsage() const {
   if (memory_usage_ == kMemoryUsageUnknown) {
     using base::trace_event::EstimateMemoryUsage;
     memory_usage_ = EstimateMemoryUsage(string_fields) +
-                    EstimateMemoryUsage(specifics_fields) +
+                    EstimateSharedMemoryUsage(specifics_fields) +
                     EstimateMemoryUsage(id_fields) +
                     EstimateMemoryUsage(unique_position_fields) +
-                    EstimateMemoryUsage(attachment_metadata_fields);
+                    EstimateSharedMemoryUsage(attachment_metadata_fields);
   }
   return memory_usage_;
 }
 
 std::unique_ptr<base::ListValue> EntryKernelMutationMapToValue(
     const EntryKernelMutationMap& mutations) {
   std::unique_ptr<base::ListValue> list(new base::ListValue());
   for (EntryKernelMutationMap::const_iterator it = mutations.begin();
        it != mutations.end(); ++it) {
     list->Append(EntryKernelMutationToValue(it->second));
@@ skipping 53 matching lines @@
   os << "TempFlags: ";
   for (; i < BIT_TEMPS_END; ++i) {
     if (kernel->ref(static_cast<BitTemp>(i)))
       os << "#" << i - BIT_TEMPS_BEGIN << ", ";
   }
   return os;
 }
 
 }  // namespace syncable
 }  // namespace syncer