Rename elements of LinkType enum

chrome/browser/chromeos/gdata/gdata_wapi_parser.cc

 // Copyright (c) 2012 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/chromeos/gdata/gdata_wapi_parser.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
@@ skipping 144 matching lines @@
     { DocumentEntry::FILE,         "file",         NULL},
     { DocumentEntry::PDF,          "pdf",          NULL},
 };
 
 struct LinkTypeMap {
   Link::LinkType type;
   const char* rel;
 };
 
 const LinkTypeMap kLinkTypeMap[] = {
-    { Link::SELF,
+    { Link::kSelf,
       "self" },
-    { Link::NEXT,
+    { Link::kNext,
       "next" },
-    { Link::PARENT,
+    { Link::kParent,
       "http://schemas.google.com/docs/2007#parent" },
-    { Link::ALTERNATE,
+    { Link::kAlternate,
       "alternate"},
-    { Link::EDIT,
+    { Link::kEdit,
       "edit" },
-    { Link::EDIT_MEDIA,
+    { Link::kEditMedia,
       "edit-media" },
-    { Link::ALT_EDIT_MEDIA,
+    { Link::kAltEditMedia,
       "http://schemas.google.com/docs/2007#alt-edit-media" },
-    { Link::ALT_POST,
+    { Link::kAltPost,
       "http://schemas.google.com/docs/2007#alt-post" },
-    { Link::FEED,
+    { Link::kFeed,
       "http://schemas.google.com/g/2005#feed"},
-    { Link::POST,
+    { Link::kPost,
       "http://schemas.google.com/g/2005#post"},
-    { Link::BATCH,
+    { Link::kBatch,
       "http://schemas.google.com/g/2005#batch"},
-    { Link::THUMBNAIL,
+    { Link::kThumbnail,
       "http://schemas.google.com/docs/2007/thumbnail"},
-    { Link::RESUMABLE_EDIT_MEDIA,
+    { Link::kResumableEditMedia,
       "http://schemas.google.com/g/2005#resumable-edit-media"},
-    { Link::RESUMABLE_CREATE_MEDIA,
+    { Link::kResumableCreateMedia,
       "http://schemas.google.com/g/2005#resumable-create-media"},
-    { Link::TABLES_FEED,
+    { Link::kTablesFeed,
       "http://schemas.google.com/spreadsheets/2006#tablesfeed"},
-    { Link::WORKSHEET_FEED,
+    { Link::kWorksheetFeed,
       "http://schemas.google.com/spreadsheets/2006#worksheetsfeed"},
-    { Link::EMBED,
+    { Link::kEmbed,
       "http://schemas.google.com/docs/2007#embed"},
-    { Link::PRODUCT,
+    { Link::kProduct,
       "http://schemas.google.com/docs/2007#product"},
-    { Link::ICON,
+    { Link::kIcon,
       "http://schemas.google.com/docs/2007#icon"},
 };
 
 struct FeedLinkTypeMap {
   FeedLink::FeedLinkType type;
   const char* rel;
 };
 
 const FeedLinkTypeMap kFeedLinkTypeMap[] = {
     { FeedLink::ACL, "http://schemas.google.com/acl/2007#accessControlList" },
@@ skipping 78 matching lines @@
      xml_reader->ReadElementContent(&author->email_);
      skip_read = true;
     }
   } while (depth == xml_reader->Depth() && (skip_read || xml_reader->Next()));
   return author;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Link implementation
 
-Link::Link() : type_(Link::UNKNOWN) {
+Link::Link() : type_(Link::kUnknown) {
 }
 
 Link::~Link() {
 }
 
 // static
 bool Link::GetAppID(const base::StringPiece& rel, std::string* app_id) {
   DCHECK(app_id);
   // Fast return path if the link clearly isn't an OPEN_WITH link.
   if (rel.size() < kOpenWithPrefixSize) {
@@ skipping 19 matching lines @@
       *type = kLinkTypeMap[i].type;
       return true;
     }
   }
 
   // OPEN_WITH links have extra information at the end of the rel that is unique
   // for each one, so we can't just check the usual map. This check is slightly
   // redundant to provide a quick skip if it's obviously not an OPEN_WITH url.
   if (rel.size() >= kOpenWithPrefixSize &&
       StartsWithASCII(rel.as_string(), kOpenWithPrefix, false)) {
-    *type = OPEN_WITH;
+    *type = kOpenWith;
     return true;
   }
 
   // Let unknown link types through, just report it; if the link type is needed
   // in the future, add it into LinkType and kLinkTypeMap.
   DVLOG(1) << "Ignoring unknown link type for rel " << rel;
-  *type = UNKNOWN;
+  *type = kUnknown;
   return true;
 }
 
 // static
 void Link::RegisterJSONConverter(base::JSONValueConverter<Link>* converter) {
   converter->RegisterCustomField<Link::LinkType>(kRelField,
                                                  &Link::type_,
                                                  &Link::GetLinkType);
   // We have to register kRelField twice because we extract two different pieces
   // of data from the same rel field.
@@ skipping 13 matching lines @@
   Link* link = new Link();
   xml_reader->NodeAttribute(kTypeAttr, &link->mime_type_);
 
   std::string href;
   if (xml_reader->NodeAttribute(kHrefAttr, &href))
       link->href_ = GURL(href);
 
   std::string rel;
   if (xml_reader->NodeAttribute(kRelAttr, &rel)) {
     GetLinkType(rel, &link->type_);
-    if (link->type_ == OPEN_WITH)
+    if (link->type_ == kOpenWith)
       GetAppID(rel, &link->app_id_);
   }
 
   return link;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // FeedLink implementation
 
 FeedLink::FeedLink() : type_(FeedLink::UNKNOWN) {
@@ skipping 137 matching lines @@
       &AppIcon::category_,
       &AppIcon::GetIconCategory);
   converter->RegisterCustomField<int>(kInstalledAppIconSizeField,
                                       &AppIcon::icon_side_length_,
                                       base::StringToInt);
   converter->RegisterRepeatedMessage(kLinkField, &AppIcon::links_);
 }
 
 GURL AppIcon::GetIconURL() const {
   for (size_t i = 0; i < links_.size(); ++i) {
-    if (links_[i]->type() == Link::ICON)
+    if (links_[i]->type() == Link::kIcon)
       return links_[i]->href();
   }
   return GURL();
 }
 
 // static
 bool AppIcon::GetIconCategory(const base::StringPiece& category,
                               AppIcon::IconCategory* result) {
   for (size_t i = 0; i < arraysize(kAppIconCategoryMap); i++) {
     if (category == kAppIconCategoryMap[i].category_name) {
@@ skipping 279 matching lines @@
   // ChangeResource, and is reflected in |removed_|. If file is trashed, the
   // file entry still exists but with its "trashed" label true.
   entry->deleted_ = file.labels().is_trashed();
 
   // FeedEntry
   entry->etag_ = file.etag();
   // entry->authors_
   // entry->links_.
   if (!file.parents().empty()) {
     Link* link = new Link();
-    link->type_ = Link::PARENT;
+    link->type_ = Link::kParent;
     link->href_ = file.parents()[0]->parent_link();
     entry->links_.push_back(link);
   }
   if (!file.self_link().is_empty()) {
     Link* link = new Link();
-    link->type_ = Link::EDIT;
+    link->type_ = Link::kEdit;
     link->href_ = file.self_link();
     entry->links_.push_back(link);
   }
   if (!file.thumbnail_link().is_empty()) {
     Link* link = new Link();
-    link->type_ = Link::THUMBNAIL;
+    link->type_ = Link::kThumbnail;
     link->href_ = file.thumbnail_link();
     entry->links_.push_back(link);
   }
   if (!file.alternate_link().is_empty()) {
     Link* link = new Link();
-    link->type_ = Link::ALTERNATE;
+    link->type_ = Link::kAlternate;
     link->href_ = file.alternate_link();
     entry->links_.push_back(link);
   }
   if (!file.embed_link().is_empty()) {
     Link* link = new Link();
-    link->type_ = Link::EMBED;
+    link->type_ = Link::kEmbed;
     link->href_ = file.embed_link();
     entry->links_.push_back(link);
   }
   // entry->categories_
   entry->updated_time_ = file.modified_by_me_date();
 
   entry->FillRemainingFields();
   return entry.release();
 }
 
@@ skipping 96 matching lines @@
     feed->entries_.push_back(DocumentEntry::CreateFromFileResource(file));
     ++iter;
   }
   feed->largest_changestamp_ = largest_changestamp;
   return feed.Pass();
 }
 
 bool DocumentFeed::GetNextFeedURL(GURL* url) {
   DCHECK(url);
   for (size_t i = 0; i < links_.size(); ++i) {
-    if (links_[i]->type() == Link::NEXT) {
+    if (links_[i]->type() == Link::kNext) {
       *url = links_[i]->href();
       return true;
     }
   }
   return false;
 }
 
 void DocumentFeed::ReleaseEntries(std::vector<DocumentEntry*>* entries) {
   entries_.release(entries);
 }
@@ skipping 24 matching lines @@
 
   // Return a sorted list, smallest to largest.
   std::sort(result.begin(), result.end(), SortBySize);
   return result;
 }
 
 GURL InstalledApp::GetProductUrl() const {
   for (ScopedVector<Link>::const_iterator it = links_.begin();
        it != links_.end(); ++it) {
     const Link* link = *it;
-    if (link->type() == Link::PRODUCT)
+    if (link->type() == Link::kProduct)
       return link->href();
   }
   return GURL();
 }
 
 // static
 bool InstalledApp::GetValueString(const base::Value* value,
                                   std::string* result) {
   const base::DictionaryValue* dict = NULL;
   if (!value->GetAsDictionary(&dict))
@@ skipping 85 matching lines @@
 bool AccountMetadataFeed::Parse(const base::Value& value) {
   base::JSONValueConverter<AccountMetadataFeed> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid account metadata feed!";
     return false;
   }
   return true;
 }
 
 }  // namespace gdata