Use Drive v2 API: enable behind --enable-drive-api flag

chrome/browser/chromeos/gdata/gdata_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_parser.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/json/json_value_converter.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "third_party/libxml/chromium/libxml_utils.h"
 
 using base::Value;
 using base::DictionaryValue;
 using base::ListValue;
 
 namespace gdata {
 
 namespace {
 
@@ skipping 99 matching lines @@
 const char kSchemeAttr[] = "scheme";
 const char kSrcAttr[] = "src";
 const char kTermAttr[] = "term";
 const char kTypeAttr[] = "type";
 const char kValueAttr[] = "value";
 
 // Link Prefixes
 const char kOpenWithPrefix[] = "http://schemas.google.com/docs/2007#open-with-";
 const size_t kOpenWithPrefixSize = arraysize(kOpenWithPrefix) - 1;
 
+// Drive API JSON names.
+const char kQuotaBytesTotal[] = "quotaBytesTotal";
+const char kQuotaBytesUsed[] = "quotaBytesUsed";
+const char kLargestChangeId[] = "largestChangeId";
+
 struct EntryKindMap {
   DocumentEntry::EntryKind kind;
   const char* entry;
   const char* extension;
 };
 
 const EntryKindMap kEntryKindMap[] = {
     { DocumentEntry::ITEM,         "item",         NULL},
     { DocumentEntry::DOCUMENT,     "document",     ".gdoc"},
     { DocumentEntry::SPREADSHEET,  "spreadsheet",  ".gsheet"},
@@ skipping 846 matching lines @@
   converter->RegisterRepeatedCustomValue(
       kInstalledAppSecondaryFileExtensionField,
       &InstalledApp::secondary_extensions_,
       &GetValueString);
   converter->RegisterRepeatedMessage(kLinkField, &InstalledApp::links_);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // AccountMetadataFeed implementation
 
+class AccountMetadataFeedDocumentList : public AccountMetadataFeed {
+ public:
+  AccountMetadataFeedDocumentList() : AccountMetadataFeed() {}
+  virtual ~AccountMetadataFeedDocumentList() {}
+
+  // Registers the mapping between JSON field names and the members in this
+  // class.
+  static void RegisterJSONConverter(
+      base::JSONValueConverter<AccountMetadataFeedDocumentList>* converter);
+
+  // Parses and initializes data members from content of |value|.
+  // Return false if parsing fails.
+  virtual bool Parse(const base::Value& value) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AccountMetadataFeedDocumentList);
+};
+
+class AccountMetadataFeedDriveAPI : public AccountMetadataFeed {

[satorux1, 2012/07/10 18:10:33]

What about creating a separate file like drive_api_parser.cc for the new Drive
API? We are going to add a bunch of code for the new Drive API, so having a
separate file would be cleaner.

The existing file should also be renamed to gdata_wapi_parser.cc or something.

[kochi, 2012/07/11 09:43:27]

At first I tried to avoid that, but it seems the difference
is significant and it makes sense to have separate parsers
and operations for Drive APIs.

For renaming this file, I have created separate CL
http://codereview.chromium.org/10692152/

+ public:
+  AccountMetadataFeedDriveAPI() : AccountMetadataFeed() {}
+  virtual ~AccountMetadataFeedDriveAPI() {}
+
+  // Registers the mapping between JSON field names and the members in this
+  // class.
+  static void RegisterJSONConverter(
+      base::JSONValueConverter<AccountMetadataFeedDriveAPI>* converter);
+
+  // Parses and initializes data members from content of |value|.
+  // Return false if parsing fails.
+  virtual bool Parse(const base::Value& value) OVERRIDE;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AccountMetadataFeedDriveAPI);
+};
+
 AccountMetadataFeed::AccountMetadataFeed()
     : quota_bytes_total_(0),
       quota_bytes_used_(0),
       largest_changestamp_(0) {
 }
 
 AccountMetadataFeed::~AccountMetadataFeed() {
 }
 
 // static
-void AccountMetadataFeed::RegisterJSONConverter(
-    base::JSONValueConverter<AccountMetadataFeed>* converter) {
-  converter->RegisterCustomField<int64>(
-      kQuotaBytesTotalField,
-      &AccountMetadataFeed::quota_bytes_total_,
-      &base::StringToInt64);
-  converter->RegisterCustomField<int64>(
-      kQuotaBytesUsedField,
-      &AccountMetadataFeed::quota_bytes_used_,
-      &base::StringToInt64);
-  converter->RegisterCustomField<int>(
-      kLargestChangestampField,
-      &AccountMetadataFeed::largest_changestamp_,
-      &base::StringToInt);
-  converter->RegisterRepeatedMessage(kInstalledAppField,
-                                     &AccountMetadataFeed::installed_apps_);
-}
-
-// static
 scoped_ptr<AccountMetadataFeed> AccountMetadataFeed::CreateFrom(
     const base::Value& value) {
-  scoped_ptr<AccountMetadataFeed> feed(new AccountMetadataFeed());
+  if (gdata::util::IsDriveV2ApiEnabled()) {
+    scoped_ptr<AccountMetadataFeedDriveAPI> feed(
+        new AccountMetadataFeedDriveAPI());
+    if (!feed->Parse(value)) {
+      LOG(ERROR) << "Unable to create: Invalid account metadata feed!";
+      return scoped_ptr<AccountMetadataFeed>(NULL);
+    }
+    return feed.PassAs<AccountMetadataFeed>();
+  }
+
+  scoped_ptr<AccountMetadataFeedDocumentList> feed(
+      new AccountMetadataFeedDocumentList());
   const base::DictionaryValue* dictionary = NULL;
   base::Value* entry = NULL;
   if (!value.GetAsDictionary(&dictionary) ||
       !dictionary->Get(kEntryField, &entry) ||
       !feed->Parse(*entry)) {
     LOG(ERROR) << "Unable to create: Invalid account metadata feed!";
     return scoped_ptr<AccountMetadataFeed>(NULL);
   }
-
-  return feed.Pass();
+  return feed.PassAs<AccountMetadataFeed>();
 }
 
-bool AccountMetadataFeed::Parse(const base::Value& value) {
-  base::JSONValueConverter<AccountMetadataFeed> converter;
+// static
+void AccountMetadataFeedDocumentList::RegisterJSONConverter(
+    base::JSONValueConverter<AccountMetadataFeedDocumentList>* converter) {
+  converter->RegisterCustomField<int64>(
+      kQuotaBytesTotalField,
+      &AccountMetadataFeedDocumentList::quota_bytes_total_,
+      &base::StringToInt64);
+  converter->RegisterCustomField<int64>(
+      kQuotaBytesUsedField,
+      &AccountMetadataFeedDocumentList::quota_bytes_used_,
+      &base::StringToInt64);
+  converter->RegisterCustomField<int>(
+      kLargestChangestampField,
+      &AccountMetadataFeedDocumentList::largest_changestamp_,
+      &base::StringToInt);
+  converter->RegisterRepeatedMessage<InstalledApp>(
+      kInstalledAppField,
+      &AccountMetadataFeedDocumentList::installed_apps_);
+}
+
+bool AccountMetadataFeedDocumentList::Parse(const base::Value& value) {
+  base::JSONValueConverter<AccountMetadataFeedDocumentList> converter;
   if (!converter.Convert(value, this)) {
     LOG(ERROR) << "Unable to parse: Invalid account metadata feed!";
     return false;
+  }
+  return true;
+}
+
+// static
+void AccountMetadataFeedDriveAPI::RegisterJSONConverter(
+    base::JSONValueConverter<AccountMetadataFeedDriveAPI>* converter) {
+  converter->RegisterCustomField<int64>(
+      kQuotaBytesTotal,
+      &AccountMetadataFeedDriveAPI::quota_bytes_total_,
+      &base::StringToInt64);
+  converter->RegisterCustomField<int64>(
+      kQuotaBytesUsed,
+      &AccountMetadataFeedDriveAPI::quota_bytes_used_,
+      &base::StringToInt64);
+  converter->RegisterCustomField<int>(
+      kLargestChangeId,
+      &AccountMetadataFeedDriveAPI::largest_changestamp_,
+      &base::StringToInt);
+  // TODO(kochi): To get installed apps, Drive V2 API needs another API call.
+}
+
+bool AccountMetadataFeedDriveAPI::Parse(const base::Value& value) {
+  base::JSONValueConverter<AccountMetadataFeedDriveAPI> converter;
+  if (!converter.Convert(value, this)) {
+    LOG(ERROR) << "Unable to parse: Invalid account metadata feed!";
+    return false;
   }
   return true;
 }
 
 }  // namespace gdata