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

chrome/browser/chromeos/gdata/gdata_file_system.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_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 655 matching lines @@
     const base::SequencedWorkerPool::SequenceToken& sequence_token)
     : profile_(profile),
       cache_(cache),
       uploader_(uploader),
       documents_service_(documents_service),
       webapps_registry_(webapps_registry),
       update_timer_(true /* retain_user_task */, true /* is_repeating */),
       hide_hosted_docs_(false),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()),
-      sequence_token_(sequence_token) {
+      sequence_token_(sequence_token),
+      use_drive_api_(false) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
-void GDataFileSystem::Initialize() {
+void GDataFileSystem::Initialize(bool use_drive_api) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  documents_service_->Initialize(profile_);
+  use_drive_api_ = use_drive_api;
+
+  documents_service_->Initialize(profile_, use_drive_api_);
 
   root_.reset(new GDataRootDirectory);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void GDataFileSystem::CheckForUpdates() {
@@ skipping 186 matching lines @@
                        std::string() /* no search query */,
                        std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
                                   ui_weak_ptr_));
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> account_metadata;
   if (feed_data.get()) {
-    account_metadata = AccountMetadataFeed::CreateFrom(*feed_data);
+    account_metadata = AccountMetadataFeed::CreateFrom(*feed_data,
+                                                       use_drive_api_);
 #ifndef NDEBUG
     // Save account metadata feed for analysis.
     const FilePath path =
         cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
             kAccountMetadataFile);
     PostBlockingPoolSequencedTask(
         FROM_HERE,
         sequence_token_,
         base::Bind(&SaveFeedOnBlockingPoolForDebugging,
                    path, base::Passed(&feed_data)));
 #endif
   }
 
   if (!account_metadata.get()) {
     LoadFeedFromServer(initial_origin,
                        local_changestamp + 1, 0,
                        true,  /* should_fetch_multiple_feeds */
                        search_file_path,
                        std::string() /* no search query */,
                        std::string() /* no directory resource ID */,
                        callback,
                        base::Bind(&GDataFileSystem::OnFeedFromServerLoaded,
                                   ui_weak_ptr_));
     return;
   }
 
-  webapps_registry_->UpdateFromFeed(account_metadata.get());
+  if (!use_drive_api_)
+    webapps_registry_->UpdateFromFeed(account_metadata.get());
 
   bool changes_detected = true;
   if (local_changestamp >= account_metadata->largest_changestamp()) {
     if (local_changestamp > account_metadata->largest_changestamp()) {
       LOG(WARNING) << "Cached client feed is fresher than server, client = "
                    << local_changestamp
                    << ", server = "
                    << account_metadata->largest_changestamp();
     }
     root_->set_origin(initial_origin);
@@ skipping 1497 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   base::PlatformFileError error = GDataToPlatformError(status);
   if (error != base::PLATFORM_FILE_OK) {
     callback.Run(error, -1, -1);
     return;
   }
 
   scoped_ptr<AccountMetadataFeed> feed;
   if (data.get())
-      feed = AccountMetadataFeed::CreateFrom(*data);
+    feed = AccountMetadataFeed::CreateFrom(*data, use_drive_api_);
   if (!feed.get()) {
     callback.Run(base::PLATFORM_FILE_ERROR_FAILED, -1, -1);
     return;
   }
 
   callback.Run(base::PLATFORM_FILE_OK,
                feed->quota_bytes_total(),
                feed->quota_bytes_used());
 }
 
@@ skipping 1474 matching lines @@
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   if (!callback.is_null())
     callback.Run(result);
 }
 
 }  // namespace gdata