Implement copy and move operations within the same remote file system.

chrome/browser/chromeos/gdata/gdata.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.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 17 matching lines @@
 #include "chrome/browser/signin/token_service.h"
 #include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/libxml_utils.h"
 #include "chrome/common/net/gaia/gaia_constants.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
+#include "net/base/escape.h"
 #include "net/base/file_stream.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 using content::BrowserThread;
 using content::URLFetcher;
 using content::URLFetcherDelegate;
 
 namespace gdata {
@@ skipping 279 matching lines @@
         callback_(callback),
         // MessageLoopProxy is used to run |callback| on the origin thread.
         relay_proxy_(base::MessageLoopProxy::current()),
         re_authenticate_count_(0),
         save_temp_file_(false) {
   }
 
   // Overridden from GDataOperationInterface.
   virtual void Start(const std::string& auth_token) OVERRIDE {
     DCHECK(!auth_token.empty());
+
     GURL url = GetURL();
-    url_fetcher_.reset(URLFetcher::Create(
-        url, GetRequestType(), this));
+    DCHECK(!url.is_empty());
+    DVLOG(1) << "URL: " << url.spec();
+
+    url_fetcher_.reset(URLFetcher::Create(url, GetRequestType(), this));
     url_fetcher_->SetRequestContext(profile_->GetRequestContext());
     // Always set flags to neither send nor save cookies.
     url_fetcher_->SetLoadFlags(
         net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
     if (save_temp_file_) {
       url_fetcher_->SaveResponseToTemporaryFile(
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));
     }
 
     // Add request headers.
     // Note that SetExtraRequestHeaders clears the current headers and sets it
     // to the passed-in headers, so calling it for each header will result in
     // only the last header being set in request headers.
     url_fetcher_->AddExtraRequestHeader(kGDataVersionHeader);
     url_fetcher_->AddExtraRequestHeader(
           base::StringPrintf(kAuthorizationHeaderFormat, auth_token.data()));
     std::vector<std::string> headers = GetExtraRequestHeaders();
     for (size_t i = 0; i < headers.size(); ++i) {
       url_fetcher_->AddExtraRequestHeader(headers[i]);
-      DVLOG(1) << "Extra header " << headers[i];
+      DVLOG(1) << "Extra header: " << headers[i];
     }
 
     // Set upload data if available.
     std::string upload_content_type;
     std::string upload_content;
     if (GetContentData(&upload_content_type, &upload_content)) {
       url_fetcher_->SetUploadData(upload_content_type, upload_content);
     }
 
     // Register to operation registry.
     NotifyStart();
 
     url_fetcher_->Start();
   }
 
   // Overridden from GDataOperationInterface.
   virtual void SetReAuthenticateCallback(
       const ReAuthenticateCallback& callback) OVERRIDE {
     DCHECK(re_authenticate_callback_.is_null());
 
     re_authenticate_callback_ = callback;
   }
 
  protected:
   virtual ~UrlFetchOperation() {}
   // Gets URL for GET request.

[satorux1, 2012/03/12 17:48:24]

Is this only for GET? Seems to be used for POST as well?

[Ben Chan, 2012/03/13 00:29:21]

Fixed the comments. Also added comments for GetExtraRequestHeaders and
GetContentData

   virtual GURL GetURL() const = 0;
   virtual URLFetcher::RequestType GetRequestType() const {
     return URLFetcher::GET;
   }
   virtual std::vector<std::string> GetExtraRequestHeaders() const {
     return std::vector<std::string>();
   }
   virtual bool GetContentData(std::string* upload_content_type,
                               std::string* upload_content) {
     return false;
@@ skipping 381 matching lines @@
   xml_writer.WriteElement("title", directory_name_);
 
   xml_writer.EndElement();  // Ends "entry" element.
   xml_writer.StopWriting();
   upload_content->assign(xml_writer.GetWrittenString());
   DVLOG(1) << "CreateDirectory data: " << *upload_content_type << ", ["
            << *upload_content << "]";
   return true;
 }
 
+//=========================== CopyDocumentOperation ============================
+
+// Operation for making a copy of a document.
+class CopyDocumentOperation : public GetDataOperation {
+ public:
+  CopyDocumentOperation(GDataOperationRegistry* registry,
+                        Profile* profile,
+                        const GetDataCallback& callback,
+                        const GURL& document_url,
+                        const FilePath::StringType& new_name);

[satorux1, 2012/03/12 17:48:24]

just fyi: matter of taste, but for small classes like this, defined in .cc file,
you can inline all functions in the class definition than to define them
outside, which results in less repetitive code. just fyi, again.

[Ben Chan, 2012/03/13 00:29:21]

I had a discussion with Zel that we would like to move all operation classes to
gdata_operations.{h,cc} as gdata.cc is getting big. But because GData is a
moving target, I defer the change until things settle down a bit.

+  virtual ~CopyDocumentOperation() {}
+
+ private:
+  // Overridden from GetDataOperation.
+  virtual URLFetcher::RequestType GetRequestType() const OVERRIDE;
+
+  // Overridden from UrlFetchOperation.
+  virtual GURL GetURL() const OVERRIDE;
+  virtual bool GetContentData(std::string* upload_content_type,
+                              std::string* upload_content) OVERRIDE;
+
+  GURL document_url_;
+  FilePath::StringType new_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(CopyDocumentOperation);
+};
+
+CopyDocumentOperation::CopyDocumentOperation(
+    GDataOperationRegistry* registry,
+    Profile* profile,
+    const GetDataCallback& callback,
+    const GURL& document_url,
+    const FilePath::StringType& new_name)
+    : GetDataOperation(registry, profile, callback),
+      document_url_(document_url),
+      new_name_(new_name) {
+}
+
+URLFetcher::RequestType CopyDocumentOperation::GetRequestType() const {
+  return URLFetcher::POST;
+}
+
+GURL CopyDocumentOperation::GetURL() const {
+  return AddStandardUrlParams(GURL(kDocumentListRootURL));
+}
+
+bool CopyDocumentOperation::GetContentData(std::string* upload_content_type,
+                                           std::string* upload_content) {
+  upload_content_type->assign("application/atom+xml");
+  XmlWriter xml_writer;
+  xml_writer.StartWriting();
+  xml_writer.StartElement("entry");
+  xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
+
+  xml_writer.WriteElement("id", document_url_.spec());
+  xml_writer.WriteElement("title", new_name_);
+
+  xml_writer.EndElement();  // Ends "entry" element.
+  xml_writer.StopWriting();
+  upload_content->assign(xml_writer.GetWrittenString());
+  DVLOG(1) << "CopyDocumentOperation data: " << *upload_content_type << ", ["
+           << *upload_content << "]";
+  return true;
+}
+
+//=========================== RenameResourceOperation ==========================
+
+class RenameResourceOperation : public EntryActionOperation {
+ public:
+  RenameResourceOperation(GDataOperationRegistry* registry,
+                          Profile* profile,
+                          const EntryActionCallback& callback,
+                          const GURL& document_url,
+                          const FilePath::StringType& new_name);
+  virtual ~RenameResourceOperation() {}
+
+ private:
+  // Overridden from EntryActionOperation.
+  virtual URLFetcher::RequestType GetRequestType() const OVERRIDE;
+  virtual std::vector<std::string> GetExtraRequestHeaders() const OVERRIDE;
+
+  // Overridden from UrlFetchOperation.
+  virtual bool GetContentData(std::string* upload_content_type,
+                              std::string* upload_content) OVERRIDE;
+
+  FilePath::StringType new_name_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenameResourceOperation);
+};
+
+RenameResourceOperation::RenameResourceOperation(
+    GDataOperationRegistry* registry,
+    Profile* profile,
+    const EntryActionCallback& callback,
+    const GURL& document_url,
+    const FilePath::StringType& new_name)
+    : EntryActionOperation(registry, profile, callback, document_url),
+      new_name_(new_name) {
+}
+
+URLFetcher::RequestType RenameResourceOperation::GetRequestType() const {
+  return URLFetcher::PUT;
+}
+
+std::vector<std::string>
+RenameResourceOperation::GetExtraRequestHeaders() const {
+  std::vector<std::string> headers;
+  headers.push_back(kIfMatchAllHeader);
+  return headers;
+}
+
+bool RenameResourceOperation::GetContentData(std::string* upload_content_type,
+                                             std::string* upload_content) {
+  upload_content_type->assign("application/atom+xml");
+  XmlWriter xml_writer;
+  xml_writer.StartWriting();
+  xml_writer.StartElement("entry");
+  xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
+
+  xml_writer.WriteElement("title", new_name_);
+
+  xml_writer.EndElement();  // Ends "entry" element.
+  xml_writer.StopWriting();
+  upload_content->assign(xml_writer.GetWrittenString());
+  DVLOG(1) << "RenameResourceOperation data: " << *upload_content_type << ", ["
+           << *upload_content << "]";
+  return true;
+}
+
+//=========================== AddResourceToDirectoryOperation ==================
+
+class AddResourceToDirectoryOperation : public EntryActionOperation {
+ public:
+  AddResourceToDirectoryOperation(GDataOperationRegistry* registry,
+                                  Profile* profile,
+                                  const EntryActionCallback& callback,
+                                  const GURL& parent_content_url,
+                                  const GURL& document_url);
+  virtual ~AddResourceToDirectoryOperation() {}
+
+ private:
+  // Overridden from EntryActionOperation.
+  virtual GURL GetURL() const OVERRIDE;
+
+  // Overridden from UrlFetchOperation.
+  virtual URLFetcher::RequestType GetRequestType() const OVERRIDE;
+  virtual bool GetContentData(std::string* upload_content_type,
+                              std::string* upload_content) OVERRIDE;
+
+  const GURL parent_content_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(AddResourceToDirectoryOperation);
+};
+
+AddResourceToDirectoryOperation::AddResourceToDirectoryOperation(
+    GDataOperationRegistry* registry,
+    Profile* profile,
+    const EntryActionCallback& callback,
+    const GURL& parent_content_url,
+    const GURL& document_url)
+    : EntryActionOperation(registry, profile, callback, document_url),
+      parent_content_url_(parent_content_url) {
+}
+
+GURL AddResourceToDirectoryOperation::GetURL() const {
+  if (!parent_content_url_.is_empty())
+    return AddStandardUrlParams(parent_content_url_);
+
+  return AddStandardUrlParams(GURL(kDocumentListRootURL));
+}
+
+URLFetcher::RequestType
+AddResourceToDirectoryOperation::GetRequestType() const {
+  return URLFetcher::POST;
+}
+
+bool AddResourceToDirectoryOperation::GetContentData(
+    std::string* upload_content_type, std::string* upload_content) {
+  upload_content_type->assign("application/atom+xml");
+  XmlWriter xml_writer;
+  xml_writer.StartWriting();
+  xml_writer.StartElement("entry");
+  xml_writer.AddAttribute("xmlns", "http://www.w3.org/2005/Atom");
+
+  xml_writer.WriteElement("id", document_url_.spec());
+
+  xml_writer.EndElement();  // Ends "entry" element.
+  xml_writer.StopWriting();
+  upload_content->assign(xml_writer.GetWrittenString());
+  DVLOG(1) << "AddResourceToDirectoryOperation data: " << *upload_content_type
+           << ", [" << *upload_content << "]";
+  return true;
+}
+
+//=========================== RemoveResourceFromDirectoryOperation =============
+
+class RemoveResourceFromDirectoryOperation : public EntryActionOperation {
+ public:
+  RemoveResourceFromDirectoryOperation(GDataOperationRegistry* registry,
+                                       Profile* profile,
+                                       const EntryActionCallback& callback,
+                                       const GURL& parent_content_url,
+                                       const GURL& document_url,
+                                       const std::string& resource_id);
+  virtual ~RemoveResourceFromDirectoryOperation() {}
+
+ private:
+  // Overridden from EntryActionOperation.
+  virtual GURL GetURL() const OVERRIDE;
+
+  // Overridden from UrlFetchOperation.
+  virtual URLFetcher::RequestType GetRequestType() const OVERRIDE;
+  virtual std::vector<std::string> GetExtraRequestHeaders() const OVERRIDE;
+
+  const std::string resource_id_;
+  const GURL parent_content_url_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveResourceFromDirectoryOperation);
+};
+
+RemoveResourceFromDirectoryOperation::RemoveResourceFromDirectoryOperation(
+    GDataOperationRegistry* registry,
+    Profile* profile,
+    const EntryActionCallback& callback,
+    const GURL& parent_content_url,
+    const GURL& document_url,
+    const std::string& document_resource_id)
+    : EntryActionOperation(registry, profile, callback, document_url),
+      resource_id_(document_resource_id),
+      parent_content_url_(parent_content_url) {
+}
+
+GURL RemoveResourceFromDirectoryOperation::GetURL() const {
+  std::string escaped_resource_id = net::EscapePath(resource_id_);
+  GURL edit_url(base::StringPrintf("%s/%s",
+                                   parent_content_url_.spec().c_str(),
+                                   escaped_resource_id.c_str()));
+  return AddStandardUrlParams(edit_url);
+}
+
+URLFetcher::RequestType
+RemoveResourceFromDirectoryOperation::GetRequestType() const {
+  return URLFetcher::DELETE_REQUEST;

[zel, 2012/03/12 20:40:40]

will this delete the file completely or just remove it from the collection?

[Ben Chan, 2012/03/13 00:29:21]

It only removes the file from collection, not the file itself.

+}
+
+std::vector<std::string>
+RemoveResourceFromDirectoryOperation::GetExtraRequestHeaders() const {
+  std::vector<std::string> headers;
+  headers.push_back(kIfMatchAllHeader);
+  return headers;
+}
+
 //=========================== InitiateUploadOperation ==========================
 
 class InitiateUploadOperation
     : public UrlFetchOperation<InitiateUploadCallback> {
  public:
   InitiateUploadOperation(GDataOperationRegistry* registry,
                           Profile* profile,
                           const InitiateUploadCallback& callback,
                           const InitiateUploadParams& params);
 
@@ skipping 399 matching lines @@
 void DocumentsService::CreateDirectory(
     const GURL& parent_content_url,
     const FilePath::StringType& directory_name,
     const GetDataCallback& callback) {
   StartOperationOnUIThread(
       new CreateDirectoryOperation(operation_registry_.get(), profile_,
                                    callback, parent_content_url,
                                    directory_name));
 }
 
+void DocumentsService::CopyDocument(const GURL& document_url,
+                                    const FilePath::StringType& new_name,
+                                    const GetDataCallback& callback) {
+  StartOperationOnUIThread(
+      new CopyDocumentOperation(operation_registry_.get(), profile_, callback,
+                                document_url, new_name));
+}
+
+void DocumentsService::RenameResource(const GURL& resource_url,
+                                      const FilePath::StringType& new_name,
+                                      const EntryActionCallback& callback) {
+  StartOperationOnUIThread(
+      new RenameResourceOperation(operation_registry_.get(), profile_, callback,
+                                  resource_url, new_name));
+}
+
+void DocumentsService::AddResourceToDirectory(
+    const GURL& parent_content_url,
+    const GURL& resource_url,
+    const EntryActionCallback& callback) {
+  StartOperationOnUIThread(
+      new AddResourceToDirectoryOperation(operation_registry_.get(),
+                                          profile_,
+                                          callback,
+                                          parent_content_url,
+                                          resource_url));
+}
+
+void DocumentsService::RemoveResourceFromDirectory(
+    const GURL& parent_content_url,
+    const GURL& resource_url,
+    const std::string& resource_id,
+    const EntryActionCallback& callback) {
+  StartOperationOnUIThread(
+      new RemoveResourceFromDirectoryOperation(operation_registry_.get(),
+                                               profile_,
+                                               callback,
+                                               parent_content_url,
+                                               resource_url,
+                                               resource_id));
+}
+
 void DocumentsService::InitiateUpload(const InitiateUploadParams& params,
                                       const InitiateUploadCallback& callback) {
   if (params.resumable_create_media_link.is_empty()) {
     if (!callback.is_null()) {
       callback.Run(HTTP_BAD_REQUEST, GURL());
     }
     return;
   }
 
   StartOperationOnUIThread(
@@ skipping 58 matching lines @@
 void DocumentsService::RetryOperation(GDataOperationInterface* operation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   gdata_auth_service_->ClearOAuth2Token();
   // User authentication might have expired - rerun the request to force
   // auth token refresh.
   StartOperation(operation);
 }
 
 }  // namespace gdata