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.
+  // Gets URL for the request.
   virtual GURL GetURL() const = 0;
+  // Returns the request type. A derived class should override this method
+  // for a request type other than HTTP GET.
   virtual URLFetcher::RequestType GetRequestType() const {
     return URLFetcher::GET;
   }
+  // Returns the extra HTTP headers for the request. A derived class should
+  // override this method to specify any extra headers needed for the request.
   virtual std::vector<std::string> GetExtraRequestHeaders() const {
     return std::vector<std::string>();
   }
+  // Used by a derived class to add any content data to the request.
+  // Returns true if |upload_content_type| and |upload_content| are updated
+  // with the content type and data for the request.
   virtual bool GetContentData(std::string* upload_content_type,
                               std::string* upload_content) {
     return false;
   }
 
   // Invoked by OnURLFetchComplete when the operation completes without an
   // authentication error. Must be implemented by a derived class.
   virtual void ProcessURLFetchResults(const URLFetcher* source) = 0;
 
   // Invoked by this base class upon an authentication error.
@@ skipping 374 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);
+  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;
+}
+
+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