1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CHROME_BROWSER_SAFE_BROWSING_TWO_PHASE_UPLOADER_H_ 6 #define CHROME_BROWSER_SAFE_BROWSING_TWO_PHASE_UPLOADER_H_ 7 8 #include <string> 9 10 #include "base/basictypes.h" 11 #include "base/callback.h" 12 #include "base/files/file_path.h" 13 #include "base/memory/scoped_ptr.h" 14 #include "base/threading/non_thread_safe.h" 15 #include "net/url_request/url_request_context_getter.h" 16 #include "url/gurl.h" 17 18 namespace base { 19 class TaskRunner; 20 } 21 namespace net { 22 class URLRequestContextGetter; 23 } 24 25 class TwoPhaseUploaderFactory; 26 27 // Implements the Google two-phase resumable upload protocol. 28 // Protocol documentation: 29 // https://developers.google.com/storage/docs/developer-guide#resumable 30 // Note: This doc is for the Cloud Storage API which specifies the POST body 31 // must be empty, however the safebrowsing use of the two-phase protocol 32 // supports sending metadata in the POST request body. We also do not need the 33 // api-version and authorization headers. 34 // TODO(mattm): support retry / resume. 35 class TwoPhaseUploader : public base::NonThreadSafe { 36 public: 37 enum State { 38 STATE_NONE, 39 UPLOAD_METADATA, 40 UPLOAD_FILE, 41 STATE_SUCCESS, 42 }; 43 typedef base::Callback<void(int64 sent, int64 total)> ProgressCallback; 44 typedef base::Callback<void(State state, 45 int net_error, 46 int response_code, 47 const std::string& response_data)> FinishCallback; 48 ~TwoPhaseUploader()49 virtual ~TwoPhaseUploader() {} 50 51 // Create the uploader. The Start method must be called to begin the upload. 52 // Network processing will use |url_request_context_getter|. 53 // The uploaded |file_path| will be read on |file_task_runner|. 54 // The first phase request will be sent to |base_url|, with |metadata| 55 // included. 56 // |progress_callback| will be called periodically as the second phase 57 // progresses, if it is non-null. 58 // On success |finish_callback| will be called with state = STATE_SUCCESS and 59 // the server response in response_data. On failure, state will specify 60 // which step the failure occurred in, and net_error, response_code, and 61 // response_data will specify information about the error. |finish_callback| 62 // will not be called if the upload is cancelled by destructing the 63 // TwoPhaseUploader object before completion. 64 static TwoPhaseUploader* Create( 65 net::URLRequestContextGetter* url_request_context_getter, 66 base::TaskRunner* file_task_runner, 67 const GURL& base_url, 68 const std::string& metadata, 69 const base::FilePath& file_path, 70 const ProgressCallback& progress_callback, 71 const FinishCallback& finish_callback); 72 73 // Makes the passed |factory| the factory used to instantiate 74 // a TwoPhaseUploader. Useful for tests. RegisterFactory(TwoPhaseUploaderFactory * factory)75 static void RegisterFactory(TwoPhaseUploaderFactory* factory) { 76 factory_ = factory; 77 } 78 79 // Begins the upload process. 80 virtual void Start() = 0; 81 82 private: 83 // The factory that controls the creation of SafeBrowsingProtocolManager. 84 // This is used by tests. 85 static TwoPhaseUploaderFactory* factory_; 86 }; 87 88 class TwoPhaseUploaderFactory { 89 public: ~TwoPhaseUploaderFactory()90 virtual ~TwoPhaseUploaderFactory() {} 91 92 virtual TwoPhaseUploader* CreateTwoPhaseUploader( 93 net::URLRequestContextGetter* url_request_context_getter, 94 base::TaskRunner* file_task_runner, 95 const GURL& base_url, 96 const std::string& metadata, 97 const base::FilePath& file_path, 98 const TwoPhaseUploader::ProgressCallback& progress_callback, 99 const TwoPhaseUploader::FinishCallback& finish_callback) = 0; 100 }; 101 102 #endif // CHROME_BROWSER_SAFE_BROWSING_TWO_PHASE_UPLOADER_H_ 103