Rename elements of LinkType enum

chrome/browser/chromeos/gdata/gdata_wapi_parser_unittest.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 "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/path_service.h"
 #include "base/string16.h"
 #include "base/time.h"
@@ skipping 76 matching lines @@
   EXPECT_EQ(1000, feed->items_per_page());
   EXPECT_EQ(update_time, feed->updated_time());
 
   // Check authors.
   ASSERT_EQ(1U, feed->authors().size());
   EXPECT_EQ(ASCIIToUTF16("tester"), feed->authors()[0]->name());
   EXPECT_EQ("tester@testing.com", feed->authors()[0]->email());
 
   // Check links.
   ASSERT_EQ(6U, feed->links().size());
-  const Link* self_link = feed->GetLinkByType(Link::SELF);
+  const Link* self_link = feed->GetLinkByType(Link::kSelf);
   ASSERT_TRUE(self_link);
   EXPECT_EQ("https://self_link/", self_link->href().spec());
   EXPECT_EQ("application/atom+xml", self_link->mime_type());
 
 
   const Link* resumable_link =
-      feed->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
+      feed->GetLinkByType(Link::kResumableCreateMedia);
   ASSERT_TRUE(resumable_link);
   EXPECT_EQ("https://resumable_create_media_link/",
             resumable_link->href().spec());
   EXPECT_EQ("application/atom+xml", resumable_link->mime_type());
 
   // Check entries.
   ASSERT_EQ(4U, feed->entries().size());
 
   // Check a folder entry.
   const DocumentEntry* folder_entry = feed->entries()[0];
@@ skipping 19 matching lines @@
             folder_entry->content_url().spec());
   EXPECT_EQ("application/atom+xml;type=feed",
             folder_entry->content_mime_type());
 
   ASSERT_EQ(1U, folder_entry->feed_links().size());
   const FeedLink* feed_link = folder_entry->feed_links()[0];
   ASSERT_TRUE(feed_link);
   ASSERT_EQ(FeedLink::ACL, feed_link->type());
 
   const Link* entry1_alternate_link =
-      folder_entry->GetLinkByType(Link::ALTERNATE);
+      folder_entry->GetLinkByType(Link::kAlternate);
   ASSERT_TRUE(entry1_alternate_link);
   EXPECT_EQ("https://1_folder_alternate_link/",
             entry1_alternate_link->href().spec());
   EXPECT_EQ("text/html", entry1_alternate_link->mime_type());
 
-  const Link* entry1_edit_link = folder_entry->GetLinkByType(Link::EDIT);
+  const Link* entry1_edit_link = folder_entry->GetLinkByType(Link::kEdit);
   ASSERT_TRUE(entry1_edit_link);
   EXPECT_EQ("https://1_edit_link/", entry1_edit_link->href().spec());
   EXPECT_EQ("application/atom+xml", entry1_edit_link->mime_type());
 
   // Check a file entry.
   const DocumentEntry* file_entry = feed->entries()[1];
   ASSERT_TRUE(file_entry);
   EXPECT_EQ(DocumentEntry::FILE, file_entry->kind());
   EXPECT_EQ(ASCIIToUTF16("filename.m4a"), file_entry->filename());
   EXPECT_EQ(ASCIIToUTF16("sugg_file_name.m4a"),
             file_entry->suggested_filename());
   EXPECT_EQ("3b4382ebefec6e743578c76bbd0575ce", file_entry->file_md5());
   EXPECT_EQ(892721, file_entry->file_size());
-  const Link* file_parent_link = file_entry->GetLinkByType(Link::PARENT);
+  const Link* file_parent_link = file_entry->GetLinkByType(Link::kParent);
   ASSERT_TRUE(file_parent_link);
   EXPECT_EQ("https://file_link_parent/", file_parent_link->href().spec());
   EXPECT_EQ("application/atom+xml", file_parent_link->mime_type());
   EXPECT_EQ(ASCIIToUTF16("Medical"), file_parent_link->title());
   const Link* file_open_with_link =
-    file_entry->GetLinkByType(Link::OPEN_WITH);
+    file_entry->GetLinkByType(Link::kOpenWith);
   ASSERT_TRUE(file_open_with_link);
   EXPECT_EQ("https://xml_file_entry_open_with_link/",
             file_open_with_link->href().spec());
   EXPECT_EQ("application/atom+xml", file_open_with_link->mime_type());
   EXPECT_EQ("the_app_id", file_open_with_link->app_id());
 
-  const Link* file_unknown_link = file_entry->GetLinkByType(Link::UNKNOWN);
+  const Link* file_unknown_link = file_entry->GetLinkByType(Link::kUnknown);
   ASSERT_TRUE(file_unknown_link);
   EXPECT_EQ("https://xml_file_fake_entry_open_with_link/",
             file_unknown_link->href().spec());
   EXPECT_EQ("application/atom+xml", file_unknown_link->mime_type());
   EXPECT_EQ("", file_unknown_link->app_id());
 
   // Check a file entry.
   const DocumentEntry* document_entry = feed->entries()[2];
   ASSERT_TRUE(document_entry);
   EXPECT_EQ(DocumentEntry::DOCUMENT, document_entry->kind());
@@ skipping 43 matching lines @@
   const FeedLink* feed_link_1 = entry->feed_links()[0];
   ASSERT_TRUE(feed_link_1);
   EXPECT_EQ(FeedLink::ACL, feed_link_1->type());
 
   const FeedLink* feed_link_2 = entry->feed_links()[1];
   ASSERT_TRUE(feed_link_2);
   EXPECT_EQ(FeedLink::REVISIONS, feed_link_2->type());
 
   // Check links.
   ASSERT_EQ(9U, entry->links().size());
-  const Link* entry1_alternate_link = entry->GetLinkByType(Link::ALTERNATE);
+  const Link* entry1_alternate_link = entry->GetLinkByType(Link::kAlternate);
   ASSERT_TRUE(entry1_alternate_link);
   EXPECT_EQ("https://xml_file_entry_id_alternate_link/",
             entry1_alternate_link->href().spec());
   EXPECT_EQ("text/html", entry1_alternate_link->mime_type());
 
-  const Link* entry1_edit_link = entry->GetLinkByType(Link::EDIT_MEDIA);
+  const Link* entry1_edit_link = entry->GetLinkByType(Link::kEditMedia);
   ASSERT_TRUE(entry1_edit_link);
   EXPECT_EQ("https://xml_file_entry_id_edit_media_link/",
             entry1_edit_link->href().spec());
   EXPECT_EQ("application/x-tar", entry1_edit_link->mime_type());
 
-  const Link* entry1_self_link = entry->GetLinkByType(Link::SELF);
+  const Link* entry1_self_link = entry->GetLinkByType(Link::kSelf);
   ASSERT_TRUE(entry1_self_link);
   EXPECT_EQ("https://xml_file_entry_id_self_link/",
             entry1_self_link->href().spec());
   EXPECT_EQ("application/atom+xml", entry1_self_link->mime_type());
   EXPECT_EQ("", entry1_self_link->app_id());
 
-  const Link* entry1_open_with_link = entry->GetLinkByType(Link::OPEN_WITH);
+  const Link* entry1_open_with_link = entry->GetLinkByType(Link::kOpenWith);
   ASSERT_TRUE(entry1_open_with_link);
   EXPECT_EQ("https://xml_file_entry_open_with_link/",
             entry1_open_with_link->href().spec());
   EXPECT_EQ("application/atom+xml", entry1_open_with_link->mime_type());
   EXPECT_EQ("the_app_id", entry1_open_with_link->app_id());
 
-  const Link* entry1_unknown_link = entry->GetLinkByType(Link::UNKNOWN);
+  const Link* entry1_unknown_link = entry->GetLinkByType(Link::kUnknown);
   ASSERT_TRUE(entry1_unknown_link);
   EXPECT_EQ("https://xml_file_fake_entry_open_with_link/",
             entry1_unknown_link->href().spec());
   EXPECT_EQ("application/atom+xml", entry1_unknown_link->mime_type());
   EXPECT_EQ("", entry1_unknown_link->app_id());
 
   // Check a file properties.
   EXPECT_EQ(DocumentEntry::FILE, entry->kind());
   EXPECT_EQ(ASCIIToUTF16("Xml Entry File Name.tar"), entry->filename());
   EXPECT_EQ(ASCIIToUTF16("Xml Entry Suggested File Name.tar"),
@@ skipping 84 matching lines @@
       FilePath(FILE_PATH_LITERAL("Test.tar.gz"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test.txt"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL("Test"))));
   EXPECT_FALSE(DocumentEntry::HasHostedDocumentExtension(
       FilePath(FILE_PATH_LITERAL(""))));
 }
 
 }  // namespace gdata