bookmarks: BookmarkNodeData's size() cleanups.

components/bookmarks/browser/bookmark_node_data.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_node_data.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/pickle.h"
@@ skipping 142 matching lines @@
 }
 
 #if !defined(OS_MACOSX)
 void BookmarkNodeData::WriteToClipboard(ui::ClipboardType clipboard_type) {
   DCHECK(clipboard_type == ui::CLIPBOARD_TYPE_COPY_PASTE ||
          clipboard_type == ui::CLIPBOARD_TYPE_SELECTION);
   ui::ScopedClipboardWriter scw(clipboard_type);
 
   // If there is only one element and it is a URL, write the URL to the
   // clipboard.
-  if (elements.size() == 1 && elements[0].is_url) {
+  if (has_single_url()) {
     const base::string16& title = elements[0].title;
     const std::string url = elements[0].url.spec();
 
     scw.WriteBookmark(title, url);
 
     // Don't call scw.WriteHyperlink() here, since some rich text editors will
     // change fonts when such data is pasted in; besides, most such editors
     // auto-linkify at some point anyway.
 
     // Also write the URL to the clipboard as text so that it can be pasted
     // into text fields. We use WriteText instead of WriteURL because we don't
     // want to clobber the X clipboard when the user copies out of the omnibox
     // on Linux (on Windows and Mac, there is no difference between these
     // functions).
     scw.WriteText(base::UTF8ToUTF16(url));
   } else {
     // We have either more than one URL, a folder, or a combination of URLs
     // and folders.
     base::string16 text;
-    for (size_t i = 0; i < elements.size(); i++) {
+    for (size_t i = 0; i < size(); i++) {
       text += i == 0 ? base::ASCIIToUTF16("") : base::ASCIIToUTF16("\n");
       if (!elements[i].is_url) {
         // Then it's a folder. Only copy the name of the folder.
         const base::string16 title = elements[i].title;
         text += title;
       } else {
         const base::string16 url = base::UTF8ToUTF16(elements[i].url.spec());
         text += url;
       }
     }
@@ skipping 33 matching lines @@
     return true;
   }
 
   return false;
 }
 #endif
 
 void BookmarkNodeData::WriteToPickle(const base::FilePath& profile_path,
                                      Pickle* pickle) const {
   profile_path.WriteToPickle(pickle);
-  pickle->WriteSizeT(elements.size());
+  pickle->WriteSizeT(size());
 
-  for (size_t i = 0; i < elements.size(); ++i)
+  for (size_t i = 0; i < size(); ++i)
     elements[i].WriteToPickle(pickle);
 }
 
 bool BookmarkNodeData::ReadFromPickle(Pickle* pickle) {
   PickleIterator data_iterator(*pickle);
   size_t element_count;
   if (profile_path_.ReadFromPickle(&data_iterator) &&
       data_iterator.ReadSizeT(&element_count)) {
     std::vector<Element> tmp_elements;
     tmp_elements.resize(element_count);
     for (size_t i = 0; i < element_count; ++i) {
       if (!tmp_elements[i].ReadFromPickle(&data_iterator)) {
         return false;
       }
     }
     elements.swap(tmp_elements);
   }
 
   return true;
 }
 
 std::vector<const BookmarkNode*> BookmarkNodeData::GetNodes(
     BookmarkModel* model,
     const base::FilePath& profile_path) const {
   std::vector<const BookmarkNode*> nodes;
 
   if (!IsFromProfilePath(profile_path))
     return nodes;
 
-  for (size_t i = 0; i < elements.size(); ++i) {
+  for (size_t i = 0; i < size(); ++i) {
     const BookmarkNode* node = GetBookmarkNodeByID(model, elements[i].id_);
     if (!node) {
       nodes.clear();
       return nodes;
     }
     nodes.push_back(node);
   }
   return nodes;
 }
 
@@ skipping 15 matching lines @@
   profile_path_ = profile_path;
 }
 
 bool BookmarkNodeData::IsFromProfilePath(
     const base::FilePath& profile_path) const {
   // An empty path means the data is not associated with any profile.
   return !profile_path_.empty() && profile_path_ == profile_path;
 }
 
 }  // namespace bookmarks