| // 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. |
| |
| #ifndef COMPONENTS_RAPPOR_LOG_UPLOADER_H_ |
| #define COMPONENTS_RAPPOR_LOG_UPLOADER_H_ |
| |
| #include <memory> |
| #include <string> |
| |
| #include "base/compiler_specific.h" |
| #include "base/containers/queue.h" |
| #include "base/macros.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/time/time.h" |
| #include "base/timer/timer.h" |
| #include "components/rappor/log_uploader_interface.h" |
| #include "url/gurl.h" |
| |
| namespace network { |
| class SimpleURLLoader; |
| class SharedURLLoaderFactory; |
| } // namespace network |
| |
| namespace rappor { |
| |
| // Uploads logs from RapporServiceImpl. Logs are passed in via QueueLog(), |
| // stored internally, and uploaded one at a time. A queued log will be uploaded |
| // at a fixed interval after the successful upload of the previous logs. If an |
| // upload fails, the uploader will keep retrying the upload with an exponential |
| // backoff interval. |
| class LogUploader : public LogUploaderInterface { |
| public: |
| // Constructor takes the |server_url| that logs should be uploaded to, the |
| // |mime_type| of the uploaded data, and |request_context| to create uploads |
| // with. |
| LogUploader( |
| const GURL& server_url, |
| const std::string& mime_type, |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory); |
| |
| // If the object is destroyed (or the program terminates) while logs are |
| // queued, the logs are lost. |
| ~LogUploader() override; |
| |
| // LogUploaderInterface: |
| void Start() override; |
| void Stop() override; |
| void QueueLog(const std::string& log) override; |
| |
| protected: |
| // Checks if an upload has been scheduled. |
| virtual bool IsUploadScheduled() const; |
| |
| // Schedules a future call to StartScheduledUpload if one isn't already |
| // pending. Can be overridden for testing. |
| virtual void ScheduleNextUpload(base::TimeDelta interval); |
| |
| // Starts transmission of the next log. Exposed for tests. |
| void StartScheduledUpload(); |
| |
| // Increases the upload interval each time it's called, to handle the case |
| // where the server is having issues. Exposed for tests. |
| static base::TimeDelta BackOffUploadInterval(base::TimeDelta); |
| |
| private: |
| // Returns true if the uploader is allowed to start another upload. |
| bool CanStartUpload() const; |
| |
| // Drops excess logs until we are under the size limit. |
| void DropExcessLogs(); |
| |
| // Called after transmission completes (whether successful or not). |
| void OnSimpleLoaderComplete(std::unique_ptr<std::string> response_body); |
| |
| // Called when the upload is completed. |
| void OnUploadFinished(bool server_is_healthy); |
| |
| // The server URL to upload logs to. |
| const GURL server_url_; |
| |
| // The mime type to specify on uploaded logs. |
| const std::string mime_type_; |
| |
| // The URL loader factory used to send uploads. |
| scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory_; |
| |
| // True if the uploader is currently running. |
| bool is_running_; |
| |
| // The outstanding transmission. |
| std::unique_ptr<network::SimpleURLLoader> simple_url_loader_; |
| |
| // The logs that still need to be uploaded. |
| base::queue<std::string> queued_logs_; |
| |
| // A timer used to delay before attempting another upload. |
| base::OneShotTimer upload_timer_; |
| |
| // Indicates that the last triggered upload hasn't resolved yet. |
| bool has_callback_pending_; |
| |
| // The interval to wait after an upload's URLFetcher completion before |
| // starting the next upload attempt. |
| base::TimeDelta upload_interval_; |
| |
| DISALLOW_COPY_AND_ASSIGN(LogUploader); |
| }; |
| |
| } // namespace rappor |
| |
| #endif // COMPONENTS_RAPPOR_LOG_UPLOADER_H_ |