Fix object ownership in ui/base/models.

components/bookmarks/browser/bookmark_codec.cc

 // Copyright 2014 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/bookmarks/browser/bookmark_codec.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
 
 #include "base/json/json_string_value_serializer.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "components/bookmarks/browser/bookmark_model.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "url/gurl.h"
 
 using base::Time;
 
@@ skipping 242 matching lines @@
 bool BookmarkCodec::DecodeNode(const base::DictionaryValue& value,
                                BookmarkNode* parent,
                                BookmarkNode* node) {
   // If no |node| is specified, we'll create one and add it to the |parent|.
   // Therefore, in that case, |parent| must be non-NULL.
   if (!node && !parent) {
     NOTREACHED();
     return false;
   }
 
+  // It's not valid to have both a node and a specified parent.
+  if (node && parent) {
+    NOTREACHED();
+    return false;
+  }
+
   std::string id_string;
   int64_t id = 0;
   if (ids_valid_) {
     if (!value.GetString(kIdKey, &id_string) ||
         !base::StringToInt64(id_string, &id) ||
         ids_.count(id) != 0) {
       ids_valid_ = false;
     } else {
       ids_.insert(id);
     }
@@ skipping 22 matching lines @@
     if (!value.GetString(kURLKey, &url_string))
       return false;
 
     GURL url = GURL(url_string);
     if (!node && url.is_valid())
       node = new BookmarkNode(id, url);
     else
       return false;  // Node invalid.
 
     if (parent)
-      parent->Add(node, parent->child_count());
+      parent->Add(base::WrapUnique(node), parent->child_count());
     node->set_type(BookmarkNode::URL);
     UpdateChecksumWithUrlNode(id_string, title, url_string);
   } else {
     std::string last_modified_date;
     if (!value.GetString(kDateModifiedKey, &last_modified_date))
       last_modified_date = base::Int64ToString(Time::Now().ToInternalValue());
 
     const base::Value* child_values;
     if (!value.Get(kChildrenKey, &child_values))
       return false;
 
     if (child_values->GetType() != base::Value::TYPE_LIST)
       return false;
 
     if (!node) {
       node = new BookmarkNode(id, GURL());
     } else {
       // If a new node is not created, explicitly assign ID to the existing one.
       node->set_id(id);
     }
 
     node->set_type(BookmarkNode::FOLDER);
     int64_t internal_time;
     base::StringToInt64(last_modified_date, &internal_time);
     node->set_date_folder_modified(Time::FromInternalValue(internal_time));
 
     if (parent)
-      parent->Add(node, parent->child_count());
+      parent->Add(base::WrapUnique(node), parent->child_count());
 
     UpdateChecksumWithFolderNode(id_string, title);
 
     const base::ListValue* child_l_values = nullptr;
     if (!child_values->GetAsList(&child_l_values))
       return false;
     if (!DecodeChildren(*child_l_values, node))
       return false;
   }
 
@@ skipping 129 matching lines @@
   base::MD5Init(&md5_context_);
 }
 
 void BookmarkCodec::FinalizeChecksum() {
   base::MD5Digest digest;
   base::MD5Final(&digest, &md5_context_);
   computed_checksum_ = base::MD5DigestToBase16(digest);
 }
 
 }  // namespace bookmarks