Add out-of-process memory logging stream parsing.

chrome/profiling/stack.cc

+// Copyright 2017 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 "chrome/profiling/stack.h"
+
+#include <algorithm>
+
+#include "base/hash.h"
+#include "chrome/profiling/profiling_globals.h"
+#include "chrome/profiling/stack_storage.h"
+
+namespace profiling {
+
+namespace {
+
+size_t ComputeHash(const std::vector<Address>& addrs) {
+  if (addrs.empty())
+    return 0;
+  // Assume Address is a POD containing only the address with no padding.
+  return base::Hash(reinterpret_cast<const char*>(&addrs[0]),
+                    addrs.size() * sizeof(Address));
+}
+
+}  // namespace
+
+Stack::Stack(std::vector<Address>&& a)
+    : addrs_(std::move(a)), hash_(ComputeHash(addrs_)) {}
+
+Stack::~Stack() {}
+
+bool Stack::operator==(const Stack& other) const {
+  if (addrs_.size() != other.addrs_.size())

[Boris Vidolov, 2017/06/17 03:13:15]

Why not compare hash_ first and do the expensive operations below only if hash_
is the same? Also, what do you think about optimizing for the same pointer if
(this == &other) return true;

[brettw, 2017/06/19 23:29:46]

The answer to both of these is that the only time this is called is for hash
collision checking. So the hash table will already have verified that the hashes
match. If we start using it in more places, this might be more useful, but I
couldn't see a common need to compare stacks for equality outside of the
containers.

+    return false;
+  for (size_t i = 0; i < addrs_.size(); i++) {
+    if (addrs_[i] != other.addrs_[i])

[Boris Vidolov, 2017/06/17 03:13:15]

I know that operator != is overridden, but I am still wondering if we can do
memcmp here. At least in theory, memcmp can use SSE instructions speeding up the
comparison several times.

[brettw, 2017/06/19 23:29:46]

I switched to memcmp.

+      return false;
+  }
+  return true;
+}
+
+bool Stack::operator!=(const Stack& other) const {
+  return !operator==(other);
+}
+
+}  // namespace profiling