Implement polling part of DriveFileSyncService

chrome/browser/sync_file_system/drive_file_sync_client.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/sync_file_system/drive_file_sync_client.h"
 
 #include <sstream>
 
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/drive_uploader.h"
 #include "chrome/browser/google_apis/gdata_wapi_service.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
+#include "chrome/common/extensions/extension.h"
+#include "extensions/common/constants.h"
 #include "net/base/escape.h"
 #include "net/base/mime_util.h"
 
 namespace sync_file_system {
 
 namespace {
 
 const char kRootResourceId[] = "";
 const char kSyncRootDirectoryName[] = "Chrome Syncable FileSystem";
-const char kResourceLinkPrefix[] =
-    "https://docs.google.com/feeds/default/private/full/";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 // This path is not actually used but is required by DriveUploaderInterface.
 const FilePath::CharType kDummyDrivePath[] =
     FILE_PATH_LITERAL("/dummy/drive/path");
 
 bool HasParentLinkTo(const ScopedVector<google_apis::Link>& links,
-                     const std::string& parent_resource_id) {
-  bool should_not_have_parent = parent_resource_id.empty();
-  GURL parent_link(kResourceLinkPrefix + net::EscapePath(parent_resource_id));
+                     const GURL& parent_link) {
+  bool should_not_have_parent = parent_link.is_empty();
 
   for (ScopedVector<google_apis::Link>::const_iterator itr = links.begin();
        itr != links.end(); ++itr) {
     if ((*itr)->type() == google_apis::Link::LINK_PARENT) {
       if (should_not_have_parent)
         return false;
-      if ((*itr)->href() == parent_link)
+      if ((*itr)->href().GetOrigin() == parent_link.GetOrigin() &&
+          (*itr)->href().path() == parent_link.path())
         return true;
     }
   }
 
   return should_not_have_parent;
 }
 
 google_apis::DocumentEntry* GetDocumentByTitleAndParent(
     const ScopedVector<google_apis::DocumentEntry>& entries,
-    const std::string& parent_resource_id,
+    const GURL& parent_link,
     const string16& title) {
   typedef ScopedVector<google_apis::DocumentEntry>::const_iterator iterator;
   for (iterator itr = entries.begin(); itr != entries.end(); ++itr) {
     if ((*itr)->title() == title &&
-        HasParentLinkTo((*itr)->links(), parent_resource_id)) {
+        HasParentLinkTo((*itr)->links(), parent_link)) {
       return *itr;
     }
   }
   return NULL;
 }
 
 }  // namespace
 
-DriveFileSyncClient::DriveFileSyncClient(Profile* profile) {
+DriveFileSyncClient::DriveFileSyncClient(Profile* profile)
+    : url_generator_(GURL(
+          google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction)) {
   drive_service_.reset(new google_apis::GDataWapiService(
       GURL(google_apis::GDataWapiUrlGenerator::kBaseUrlForProduction),
       "" /* custom_user_agent */));
   drive_service_->Initialize(profile);
 
   drive_uploader_.reset(new google_apis::DriveUploader(drive_service_.get()));
 }
 
 scoped_ptr<DriveFileSyncClient> DriveFileSyncClient::CreateForTesting(
     Profile* profile,
+    const GURL& base_url,
     scoped_ptr<google_apis::DriveServiceInterface> drive_service,
     scoped_ptr<google_apis::DriveUploaderInterface> drive_uploader) {
   return make_scoped_ptr(new DriveFileSyncClient(
-      profile, drive_service.Pass(), drive_uploader.Pass()));
+      profile, base_url, drive_service.Pass(), drive_uploader.Pass()));
 }
 
 DriveFileSyncClient::DriveFileSyncClient(
     Profile* profile,
+    const GURL& base_url,
     scoped_ptr<google_apis::DriveServiceInterface> drive_service,
-    scoped_ptr<google_apis::DriveUploaderInterface> drive_uploader) {
+    scoped_ptr<google_apis::DriveUploaderInterface> drive_uploader)
+    : url_generator_(base_url) {
   drive_service_ = drive_service.Pass();
   drive_service_->Initialize(profile);
 
   drive_uploader_ = drive_uploader.Pass();
 }
 
 DriveFileSyncClient::~DriveFileSyncClient() {
   DCHECK(CalledOnValidThread());
   drive_service_->CancelAll();
 }
 
 void DriveFileSyncClient::GetDriveDirectoryForSyncRoot(
     const ResourceIdCallback& callback) {
   DCHECK(CalledOnValidThread());
 
   std::string directory_name(kSyncRootDirectoryName);
   SearchFilesInDirectory(
       kRootResourceId,
       FormatTitleQuery(directory_name),
       base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
                  kRootResourceId, directory_name, callback));
 }
 
 void DriveFileSyncClient::GetDriveDirectoryForOrigin(
     const std::string& sync_root_resource_id,
     const GURL& origin,
     const ResourceIdCallback& callback) {
   DCHECK(CalledOnValidThread());
 
-  std::string directory_name(origin.spec());
+  std::string directory_name(OriginToDirectoryTitle(origin));
   SearchFilesInDirectory(
       sync_root_resource_id,
       FormatTitleQuery(directory_name),
       base::Bind(&DriveFileSyncClient::DidGetDirectory, AsWeakPtr(),
                  sync_root_resource_id, directory_name, callback));
 }
 
 void DriveFileSyncClient::DidGetDirectory(
     const std::string& parent_resource_id,
     const std::string& directory_name,
     const ResourceIdCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<google_apis::DocumentFeed> feed) {
   DCHECK(CalledOnValidThread());
   DCHECK(IsStringASCII(directory_name));
 
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(error, std::string());
     return;
   }
 
+  GURL parent_link;
+  if (!parent_resource_id.empty())
+    parent_link = ResourceIdToResourceLink(parent_resource_id);
   google_apis::DocumentEntry* entry = GetDocumentByTitleAndParent(
-      feed->entries(), parent_resource_id, ASCIIToUTF16(directory_name));
+      feed->entries(), parent_link, ASCIIToUTF16(directory_name));
   if (!entry) {
     if (parent_resource_id.empty()) {
       // Use empty content URL for root directory.
       drive_service_->AddNewDirectory(
           GURL(),  // parent_content_url
           FilePath().AppendASCII(directory_name).value(),
           base::Bind(&DriveFileSyncClient::DidCreateDirectory,
                      AsWeakPtr(), callback));
       return;
     }
@@ skipping 199 matching lines @@
     const GDataErrorCallback& callback) {
   DCHECK(CalledOnValidThread());
   drive_service_->GetDocumentEntry(
       resource_id,
       base::Bind(&DriveFileSyncClient::DidGetDocumentEntryData,
                  AsWeakPtr(),
                  base::Bind(&DriveFileSyncClient::DeleteFileInternal,
                             AsWeakPtr(), remote_file_md5, callback)));
 }
 
+// static
+std::string DriveFileSyncClient::OriginToDirectoryTitle(const GURL& origin) {
+  DCHECK(origin.SchemeIs(extensions::kExtensionScheme));
+  return origin.host();
+}
+
+// static
+GURL DriveFileSyncClient::DirectoryTitleToOrigin(const std::string& title) {
+  return extensions::Extension::GetBaseURLFromExtensionId(title);
+}
+
+GURL DriveFileSyncClient::ResourceIdToResourceLink(
+    const std::string& resource_id) const {
+  return url_generator_.GenerateDocumentEntryUrl(resource_id);
+}
+
 void DriveFileSyncClient::DidGetDocumentFeedData(
     const DocumentFeedCallback& callback,
     google_apis::GDataErrorCode error,
     scoped_ptr<base::Value> data) {
   DCHECK(CalledOnValidThread());
 
   if (error != google_apis::HTTP_SUCCESS) {
     callback.Run(error, scoped_ptr<google_apis::DocumentFeed>());
     return;
   }
@@ skipping 229 matching lines @@
 }
 
 void DriveFileSyncClient::DidDeleteFile(
     const GDataErrorCallback& callback,
     google_apis::GDataErrorCode error) {
   DCHECK(CalledOnValidThread());
   callback.Run(error);
 }
 
 }  // namespace sync_file_system