Converting the history::StarredEntry::Type to a type defined in BookmarkNode....

chrome/browser/bookmarks/bookmark_html_writer.cc

 // Copyright (c) 2006-2008 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/browser/bookmarks/bookmark_html_writer.h"
 
 #include "app/l10n_util.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
@@ skipping 91 matching lines @@
         !roots_d_value->Get(BookmarkCodec::kOtherBookmarkFolderNameKey,
                             &other_folder_value) ||
         other_folder_value->GetType() != Value::TYPE_DICTIONARY) {
       NOTREACHED();
       return;  // Invalid type for root folder and/or other folder.
     }
 
     IncrementIndent();
 
     if (!WriteNode(*static_cast<DictionaryValue*>(root_folder_value),
-                   history::StarredEntry::BOOKMARK_BAR) ||
+                   BookmarkNode::BOOKMARK_BAR) ||
         !WriteNode(*static_cast<DictionaryValue*>(other_folder_value),
-                   history::StarredEntry::OTHER)) {
+                   BookmarkNode::OTHER_NODE)) {
       return;
     }
 
     DecrementIndent();
 
     Write(kFolderChildrenEnd);
     Write(kNewline);
   }
 
  private:
@@ skipping 72 matching lines @@
   // Converts a time string written to the JSON codec into a time_t string
   // (used by bookmarks.html) and writes it.
   bool WriteTime(const std::wstring& time_string) {
     base::Time time = base::Time::FromInternalValue(
         StringToInt64(WideToUTF16Hack(time_string)));
     return Write(Int64ToString(time.ToTimeT()));
   }
 
   // Writes the node and all its children, returning true on success.
   bool WriteNode(const DictionaryValue& value,
-                 history::StarredEntry::Type folder_type) {
+                BookmarkNode::Type folder_type) {
     std::wstring title, date_added_string, type_string;
     if (!value.GetString(BookmarkCodec::kNameKey, &title) ||
         !value.GetString(BookmarkCodec::kDateAddedKey, &date_added_string) ||
         !value.GetString(BookmarkCodec::kTypeKey, &type_string) ||
         (type_string != BookmarkCodec::kTypeURL &&
          type_string != BookmarkCodec::kTypeFolder))  {
       NOTREACHED();
       return false;
     }
 
@@ skipping 20 matching lines @@
     // Folder.
     std::wstring last_modified_date;
     Value* child_values;
     if (!value.GetString(BookmarkCodec::kDateModifiedKey,
                          &last_modified_date) ||
         !value.Get(BookmarkCodec::kChildrenKey, &child_values) ||
         child_values->GetType() != Value::TYPE_LIST) {
       NOTREACHED();
       return false;
     }
-    if (folder_type != history::StarredEntry::OTHER) {
+    if (folder_type != BookmarkNode::OTHER_NODE) {
       // The other folder name is not written out. This gives the effect of
       // making the contents of the 'other folder' be a sibling to the bookmark
       // bar folder.
       if (!WriteIndent() ||
           !Write(kFolderStart) ||
           !WriteTime(date_added_string) ||
           !Write(kLastModified) ||
           !WriteTime(last_modified_date)) {
         return false;
       }
-      if (folder_type == history::StarredEntry::BOOKMARK_BAR) {
+      if (folder_type == BookmarkNode::BOOKMARK_BAR) {
         if (!Write(kBookmarkBar))
           return false;
         title = l10n_util::GetString(IDS_BOOMARK_BAR_FOLDER_NAME);
       } else if (!Write(kFolderAttributeEnd)) {
         return false;
       }
       if (!Write(title, CONTENT) ||
           !Write(kFolderEnd) ||
           !Write(kNewline) ||
           !WriteIndent() ||
           !Write(kFolderChildren) ||
           !Write(kNewline)) {
         return false;
       }
       IncrementIndent();
     }
 
     // Write the children.
     ListValue* children = static_cast<ListValue*>(child_values);
     for (size_t i = 0; i < children->GetSize(); ++i) {
       Value* child_value;
       if (!children->Get(i, &child_value) ||
           child_value->GetType() != Value::TYPE_DICTIONARY) {
         NOTREACHED();
         return false;
       }
       if (!WriteNode(*static_cast<DictionaryValue*>(child_value),
-                     history::StarredEntry::USER_GROUP)) {
+                     BookmarkNode::FOLDER)) {
         return false;
       }
     }
-    if (folder_type != history::StarredEntry::OTHER) {
+    if (folder_type != BookmarkNode::OTHER_NODE) {
       // Close out the folder.
       DecrementIndent();
       if (!WriteIndent() ||
           !Write(kFolderChildrenEnd) ||
           !Write(kNewline)) {
         return false;
       }
     }
     return true;
   }
@@ skipping 24 matching lines @@
   BookmarkCodec codec;
   scoped_ptr<Writer> writer(new Writer(codec.Encode(model),
                             FilePath::FromWStringHack(path)));
   if (thread)
     thread->PostTask(FROM_HERE, writer.release());
   else
     writer->Run();
 }
 
 }  // namespace bookmark_html_writer