Get rid of DriveEntryKind.

google_apis/drive/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 "google_apis/drive/gdata_wapi_parser.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 56 matching lines @@
 const char kTitleTField[] = "title.$t";
 const char kTypeField[] = "type";
 const char kUpdatedField[] = "updated.$t";
 
 // Link Prefixes
 const char kOpenWithPrefix[] = "http://schemas.google.com/docs/2007#open-with-";
 const size_t kOpenWithPrefixSize = arraysize(kOpenWithPrefix) - 1;
 
 struct EntryKindMap {
   DriveEntryKind kind;
   const char* entry;

[fukino, 2014/07/10 06:45:28]

Only ResourceEntry has dependency on the relationship between EntryKindMap::kind
and EntryKindMap::entry, so I keep this information inside ResourceEntry (and
information about relationship between kind and extension is moved to
drive_entry_kinds.cc).

-  const char* extension;
 };
 
 const EntryKindMap kEntryKindMap[] = {
-    { ENTRY_KIND_UNKNOWN,      "unknown",      NULL},
-    { ENTRY_KIND_ITEM,         "item",         NULL},
-    { ENTRY_KIND_DOCUMENT,     "document",     ".gdoc"},
-    { ENTRY_KIND_SPREADSHEET,  "spreadsheet",  ".gsheet"},
-    { ENTRY_KIND_PRESENTATION, "presentation", ".gslides" },
-    { ENTRY_KIND_DRAWING,      "drawing",      ".gdraw"},
-    { ENTRY_KIND_TABLE,        "table",        ".gtable"},
-    { ENTRY_KIND_FORM,         "form",         ".gform"},
-    { ENTRY_KIND_EXTERNAL_APP, "externalapp",  ".glink"},
-    { ENTRY_KIND_SITE,         "site",         NULL},
-    { ENTRY_KIND_FOLDER,       "folder",       NULL},
-    { ENTRY_KIND_FILE,         "file",         NULL},
-    { ENTRY_KIND_PDF,          "pdf",          NULL},
+    { ENTRY_KIND_UNKNOWN,      "unknown"},
+    { ENTRY_KIND_ITEM,         "item"},
+    { ENTRY_KIND_DOCUMENT,     "document"},
+    { ENTRY_KIND_SPREADSHEET,  "spreadsheet"},
+    { ENTRY_KIND_PRESENTATION, "presentation"},
+    { ENTRY_KIND_DRAWING,      "drawing"},
+    { ENTRY_KIND_TABLE,        "table"},
+    { ENTRY_KIND_FORM,         "form"},
+    { ENTRY_KIND_EXTERNAL_APP, "externalapp"},
+    { ENTRY_KIND_SITE,         "site"},
+    { ENTRY_KIND_FOLDER,       "folder"},
+    { ENTRY_KIND_FILE,         "file"},
+    { ENTRY_KIND_PDF,          "pdf"},
 };
 COMPILE_ASSERT(arraysize(kEntryKindMap) == ENTRY_KIND_MAX_VALUE,
                EntryKindMap_and_DriveEntryKind_are_not_in_sync);
 
 struct LinkTypeMap {
   Link::LinkType type;
   const char* rel;
 };
 
 const LinkTypeMap kLinkTypeMap[] = {
@@ skipping 327 matching lines @@
       kDeletedField, &ResourceEntry::deleted_, &ResourceEntry::HasFieldPresent);
   converter->RegisterCustomValueField<bool>(
       kRemovedField, &ResourceEntry::removed_, &ResourceEntry::HasFieldPresent);
   converter->RegisterCustomValueField<int64>(
       kChangestampField, &ResourceEntry::changestamp_,
       &ResourceEntry::ParseChangestamp);
   // ImageMediaMetadata fields are not supported by WAPI.
 }
 
 // static
-std::string ResourceEntry::GetHostedDocumentExtension(DriveEntryKind kind) {
-  for (size_t i = 0; i < arraysize(kEntryKindMap); i++) {
-    if (kEntryKindMap[i].kind == kind) {
-      if (kEntryKindMap[i].extension)
-        return std::string(kEntryKindMap[i].extension);
-      else
-        return std::string();
-    }
-  }
-  return std::string();
-}
-
-// static
-DriveEntryKind ResourceEntry::GetEntryKindFromExtension(
-    const std::string& extension) {
-  for (size_t i = 0; i < arraysize(kEntryKindMap); ++i) {
-    const char* document_extension = kEntryKindMap[i].extension;
-    if (document_extension && extension == document_extension)
-      return kEntryKindMap[i].kind;
-  }
-  return ENTRY_KIND_UNKNOWN;
-}
-
-// static
-int ResourceEntry::ClassifyEntryKindByFileExtension(
-    const base::FilePath& file_path) {
-#if defined(OS_WIN)
-  std::string file_extension = base::WideToUTF8(file_path.Extension());
-#else
-  std::string file_extension = file_path.Extension();
-#endif
-  return ClassifyEntryKind(GetEntryKindFromExtension(file_extension));
-}
-
-// static
 DriveEntryKind ResourceEntry::GetEntryKindFromTerm(
     const std::string& term) {
   if (!StartsWithASCII(term, kTermPrefix, false)) {
     DVLOG(1) << "Unexpected term prefix term " << term;
     return ENTRY_KIND_UNKNOWN;
   }
 
   std::string type = term.substr(strlen(kTermPrefix));
   for (size_t i = 0; i < arraysize(kEntryKindMap); i++) {
     if (type == kEntryKindMap[i].entry)
       return kEntryKindMap[i].kind;
   }
   DVLOG(1) << "Unknown entry type for term " << term << ", type " << type;
   return ENTRY_KIND_UNKNOWN;
 }
 
-// static
-int ResourceEntry::ClassifyEntryKind(DriveEntryKind kind) {
-  int classes = 0;
-
-  // All DriveEntryKind members are listed here, so the compiler catches if a
-  // newly added member is missing here.
-  switch (kind) {
-    case ENTRY_KIND_UNKNOWN:
-    // Special entries.
-    case ENTRY_KIND_ITEM:
-    case ENTRY_KIND_SITE:
-      break;
-
-    // Hosted Google document.
-    case ENTRY_KIND_DOCUMENT:
-    case ENTRY_KIND_SPREADSHEET:
-    case ENTRY_KIND_PRESENTATION:
-    case ENTRY_KIND_DRAWING:
-    case ENTRY_KIND_TABLE:
-    case ENTRY_KIND_FORM:
-      classes = KIND_OF_GOOGLE_DOCUMENT | KIND_OF_HOSTED_DOCUMENT;
-      break;
-
-    // Hosted external application document.
-    case ENTRY_KIND_EXTERNAL_APP:
-      classes = KIND_OF_EXTERNAL_DOCUMENT | KIND_OF_HOSTED_DOCUMENT;
-      break;
-
-    // Folders, collections.
-    case ENTRY_KIND_FOLDER:
-      classes = KIND_OF_FOLDER;
-      break;
-
-    // Regular files.
-    case ENTRY_KIND_FILE:
-    case ENTRY_KIND_PDF:
-      classes = KIND_OF_FILE;
-      break;
-
-    case ENTRY_KIND_MAX_VALUE:
-      NOTREACHED();
-  }
-
-  return classes;
-}
-
 void ResourceEntry::FillRemainingFields() {
   // Set |kind_| and |labels_| based on the |categories_| in the class.
   // JSONValueConverter does not have the ability to catch an element in a list
   // based on a predicate.  Thus we need to iterate over |categories_| and
   // find the elements to set these fields as a post-process.
   for (size_t i = 0; i < categories_.size(); ++i) {
     const Category* category = categories_[i];
     if (category->type() == Category::CATEGORY_KIND)
       kind_ = GetEntryKindFromTerm(category->term());
     else if (category->type() == Category::CATEGORY_LABEL)
@@ skipping 109 matching lines @@
     }
   }
   return false;
 }
 
 void ResourceList::ReleaseEntries(std::vector<ResourceEntry*>* entries) {
   entries_.release(entries);
 }
 
 }  // namespace google_apis