RAPPOR implementation

components/rappor/log_uploader.h

+// 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 <queue>
+#include <string>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/time/time.h"
+#include "base/timer/timer.h"
+#include "net/url_request/url_fetcher.h"

[wtc, 2014/02/10 20:12:54]

Nit: a forward declaration of class URLFetcher may suffice, but it may not be
worth the trouble.

[Steven Holte, 2014/02/10 22:50:54]

Done.

+#include "net/url_request/url_fetcher_delegate.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "url/gurl.h"
+
+namespace rappor {
+
+// Handles uploading logs to an external server.
+class LogUploader : public net::URLFetcherDelegate {
+ 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,
+              net::URLRequestContextGetter* request_context);
+
+  ~LogUploader();
+
+  // Adds an entry to the queue of logs to be uploaded to the server.  The
+  // uploader makes no assumptions about the format of |log| and simply sends
+  // it verbatim to the server.
+  void QueueLog(const std::string& log);
+
+  // Increases the upload interval each time it's called, to handle the case
+  // where the server is having issues.
+  static base::TimeDelta BackOffUploadInterval(base::TimeDelta);
+
+ protected:
+  // Schedules a future call to StartScheduledUpload if one isn't already
+  // pending.  Can be overridden for testing.
+  virtual void ScheduleNextUpload(base::TimeDelta interval);
+
+  // Check if an upload has been scheduled.
+  virtual bool IsUploadScheduled() const;
+
+  // Starts transmission of the next log. Exposed for tests.
+  void StartScheduledUpload();
+
+ private:
+  // Implementation of net::URLFetcherDelegate. Called after transmission
+  // completes (either successfully or with failure).
+  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
+
+  // Called when the upload is completed.
+  void OnUploadFinished(bool server_is_healthy, bool more_logs_remaining);
+
+  // The server URL to upload logs to.
+  const GURL server_url_;
+
+  // The mime type to specify on uploaded logs.
+  const std::string mime_type_;
+
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
+
+  // The outstanding transmission appears as a URL Fetch operation.
+  scoped_ptr<net::URLFetcher> current_fetch_;
+
+  // The logs that still need to be uploaded.
+  std::queue<std::string> queued_logs_;
+
+  base::OneShotTimer<LogUploader> 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_