Initial commit of sync engine code to browser/sync....

chrome/browser/sync/notifier/base/utils.h

+// Copyright (c) 2009 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.
+//
+// Utility functions
+
+#ifndef CHROME_BROWSER_SYNC_NOTIFIER_BASE_UTILS_H_
+#define CHROME_BROWSER_SYNC_NOTIFIER_BASE_UTILS_H_
+
+#include <map>
+#include <string>
+
+#include "chrome/browser/sync/notifier/base/static_assert.h"
+
+// return error if the first argument evaluates to false
+#define RET_IF_FALSE(x) do { if (!(x)) return false; } while (false)
+
+// Protocol constants
+const char kHttpProto[] = "http://";
+const char kHttpsProto[] = "https://";
+
+// Initialize a POD to zero.
+// Using this function requires discipline. Don't use for types that have a
+// v-table or virtual bases.
+template <typename T>
+inline void SetZero(T& p) {
+  // Guard against the easy mistake of
+  //    foo(int *p) { SetZero(p); } instead of
+  //                  SetZero(*p);
+  // which it should be.
+  STATIC_ASSERT(sizeof(T) != sizeof(void*));
+
+  // A POD (plain old data) object has one of these data types:
+  // a fundamental type, union, struct, array,
+  // or class--with no constructor. PODs don't have virtual functions or
+  // virtual bases.
+
+  // Test to see if the type has constructors.
+  union CtorTest {
+      T t;
+      int i;
+  };
+
+  // TODO(sync) There might be a way to test if the type has virtuals
+  // For now, if we zero a type with virtuals by mistake, it is going to crash
+  // predictable at run-time when the virtuals are called.
+  memset(&p, 0, sizeof(T));
+}
+
+// Used to delete each element in a vector<T*>/deque<T*>
+// (and then empty the sequence).
+template <class T>
+void CleanupSequence(T* items) {
+  for (typename T::iterator it(items->begin()); it != items->end(); ++it) {
+    delete (*it);
+  }
+  items->clear();
+}
+
+// Typically used to clean up values used in a hash_map
+// that had Type* as values.
+//
+// WARNING: This function assumes that T::clear will not access the values
+//   (or the keys if they are the same as the values).  This is true
+//   for hash_map.
+template <class T>
+void CleanupMap(T* items) {
+  // This is likely slower than a for loop, but we have to do it this way. In
+  // some of the maps we use, deleting it->second causes it->first to be deleted
+  // as well, and that seems to send the iterator in a tizzy.
+  typename T::iterator it = items->begin();
+  while (it != items->end()) {
+    items->erase(it->first);
+    delete it->second;
+    it = items->begin();
+  }
+}
+
+// Get the value of an element in the map with the specified name
+template <class T>
+void GetMapElement(const std::map<const std::string, const T>& m,
+                   const char* name,
+                   T* value) {
+  typename std::map<const std::string, const T>::const_iterator iter(
+      m.find(name));
+  if (iter != m.end()) {
+    *value = iter->second;
+  }
+}
+
+#endif  // CHROME_BROWSER_SYNC_NOTIFIER_BASE_UTILS_H_