Consolidate attachment URL construction.

sync/internal_api/attachments/attachment_uploader_impl.cc

 // Copyright 2014 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 "sync/internal_api/public/attachments/attachment_uploader_impl.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/non_thread_safe.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "sync/api/attachments/attachment.h"
 #include "sync/protocol/sync.pb.h"
-#include "url/gurl.h"
 
 namespace {
 
 const char kContentType[] = "application/octet-stream";
+const char kAttachments[] = "attachments/";
 
 }  // namespace
 
 namespace syncer {
 
 // Encapsulates all the state associated with a single upload.
 class AttachmentUploaderImpl::UploadState : public net::URLFetcherDelegate,
                                             public OAuth2TokenService::Consumer,
                                             public base::NonThreadSafe {
  public:
@@ skipping 170 matching lines @@
   for (; iter != end; ++iter) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(*iter, result, attachment_id));
   }
   // Destroy this object and return immediately.
   owner_->DeleteUploadStateFor(attachment_.GetId().GetProto().unique_id());
   return;
 }
 
 AttachmentUploaderImpl::AttachmentUploaderImpl(
-    const std::string& url_prefix,
+    const GURL& sync_service_url,
     const scoped_refptr<net::URLRequestContextGetter>&
         url_request_context_getter,
     const std::string& account_id,
     const OAuth2TokenService::ScopeSet& scopes,
     scoped_ptr<OAuth2TokenServiceRequest::TokenServiceProvider>
         token_service_provider)
-    : url_prefix_(url_prefix),
+    : sync_service_url_(sync_service_url),
       url_request_context_getter_(url_request_context_getter),
       account_id_(account_id),
       scopes_(scopes),
       token_service_provider_(token_service_provider.Pass()) {
   DCHECK(CalledOnValidThread());
   DCHECK(token_service_provider_);
 }
 
 AttachmentUploaderImpl::~AttachmentUploaderImpl() {
   DCHECK(CalledOnValidThread());
 }
 
 void AttachmentUploaderImpl::UploadAttachment(const Attachment& attachment,
                                               const UploadCallback& callback) {
   DCHECK(CalledOnValidThread());
   const AttachmentId attachment_id = attachment.GetId();
   const std::string unique_id = attachment_id.GetProto().unique_id();
   DCHECK(!unique_id.empty());
   StateMap::iterator iter = state_map_.find(unique_id);
   if (iter == state_map_.end()) {
-    const GURL url = GetUploadURLForAttachmentId(attachment_id);
+    const GURL url = GetURLForAttachmentId(sync_service_url_, attachment_id);
     scoped_ptr<UploadState> upload_state(
         new UploadState(url,
                         url_request_context_getter_,
                         attachment,
                         callback,
                         account_id_,
                         scopes_,
                         token_service_provider_.get(),
                         this));
     state_map_.add(unique_id, upload_state.Pass());
   } else {
     DCHECK(
         attachment.GetData()->Equals(iter->second->GetAttachment().GetData()));
     // We already have an upload for this attachment.  "Join" it.
     iter->second->AddUserCallback(callback);
   }
 }
 
-GURL AttachmentUploaderImpl::GetUploadURLForAttachmentId(
-    const AttachmentId& attachment_id) const {
-  return GURL(url_prefix_ + attachment_id.GetProto().unique_id());
+// Static.
+GURL AttachmentUploaderImpl::GetURLForAttachmentId(
+    const GURL& sync_service_url,
+    const AttachmentId& attachment_id) {
+  std::string path = sync_service_url.path();
+  if (path.empty() || *path.rbegin() != '/') {
+    path += '/';
+  }
+  path += kAttachments;
+  path += attachment_id.GetProto().unique_id();
+  GURL::Replacements replacements;
+  replacements.SetPathStr(path);
+  return sync_service_url.ReplaceComponents(replacements);
 }
 
 void AttachmentUploaderImpl::DeleteUploadStateFor(const UniqueId& unique_id) {
   state_map_.erase(unique_id);
 }
 
 }  // namespace syncer