Add CloudExternalDataPolicyObserverChromeOS

components/policy/core/common/policy_map.cc

 // Copyright 2013 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/policy/core/common/policy_map.h"
 
 #include <algorithm>
 
 #include "base/callback.h"
 #include "base/stl_util.h"
 
 namespace policy {
 
+void PolicyMap::Entry::DeleteOwnedMembers() {
+  delete value;
+  value = NULL;
+  delete external_data_fetcher;
+  external_data_fetcher = NULL;
+}
+
+scoped_ptr<PolicyMap::Entry> PolicyMap::Entry::DeepCopy() const {
+  scoped_ptr<Entry> copy(new Entry);
+  copy->level = level;
+  copy->scope = scope;
+  if (value)
+    copy->value = value->DeepCopy();
+  if (external_data_fetcher) {
+    copy->external_data_fetcher =
+        new ExternalDataFetcher(*external_data_fetcher);
+  }
+  return copy.Pass();
+}
+
 bool PolicyMap::Entry::has_higher_priority_than(
     const PolicyMap::Entry& other) const {
   if (level == other.level)
     return scope > other.scope;
   else
     return level > other.level;
 }
 
 bool PolicyMap::Entry::Equals(const PolicyMap::Entry& other) const {
   return level == other.level &&
@@ skipping 19 matching lines @@
   PolicyMapType::const_iterator entry = map_.find(policy);
   return entry == map_.end() ? NULL : entry->second.value;
 }
 
 void PolicyMap::Set(const std::string& policy,
                     PolicyLevel level,
                     PolicyScope scope,
                     Value* value,
                     ExternalDataFetcher* external_data_fetcher) {
   Entry& entry = map_[policy];
-  delete entry.value;
-  delete entry.external_data_fetcher;
+  entry.DeleteOwnedMembers();
   entry.level = level;
   entry.scope = scope;
   entry.value = value;
   entry.external_data_fetcher = external_data_fetcher;
 }
 
 void PolicyMap::Erase(const std::string& policy) {
   PolicyMapType::iterator it = map_.find(policy);
   if (it != map_.end()) {
-    delete it->second.value;
-    delete it->second.external_data_fetcher;
+    it->second.DeleteOwnedMembers();
     map_.erase(it);
   }
 }
 
 void PolicyMap::Swap(PolicyMap* other) {
   map_.swap(other->map_);
 }
 
 void PolicyMap::CopyFrom(const PolicyMap& other) {
   Clear();
@@ skipping 56 matching lines @@
   for ( ; iter_this != end(); ++iter_this)
       differing_keys->insert(iter_this->first);
   for ( ; iter_other != other.end(); ++iter_other)
       differing_keys->insert(iter_other->first);
 }
 
 void PolicyMap::FilterLevel(PolicyLevel level) {
   PolicyMapType::iterator iter(map_.begin());
   while (iter != map_.end()) {
     if (iter->second.level != level) {
-      delete iter->second.value;
-      delete iter->second.external_data_fetcher;
+      iter->second.DeleteOwnedMembers();
       map_.erase(iter++);
     } else {
       ++iter;
     }
   }
 }
 
 bool PolicyMap::Equals(const PolicyMap& other) const {
   return other.size() == size() &&
       std::equal(begin(), end(), other.begin(), MapEntryEquals);
 }
 
 bool PolicyMap::empty() const {
   return map_.empty();
 }
 
 size_t PolicyMap::size() const {
   return map_.size();
 }
 
 PolicyMap::const_iterator PolicyMap::begin() const {
   return map_.begin();
 }
 
 PolicyMap::const_iterator PolicyMap::end() const {
   return map_.end();
 }
 
 void PolicyMap::Clear() {
-  for (PolicyMapType::iterator it = map_.begin(); it != map_.end(); ++it) {
-    delete it->second.value;
-    delete it->second.external_data_fetcher;
-  }
+  for (PolicyMapType::iterator it = map_.begin(); it != map_.end(); ++it)
+    it->second.DeleteOwnedMembers();
   map_.clear();
 }
 
 // static
 bool PolicyMap::MapEntryEquals(const PolicyMap::PolicyMapType::value_type& a,
                                const PolicyMap::PolicyMapType::value_type& b) {
   return a.first == b.first && a.second.Equals(b.second);
 }
 
 }  // namespace policy