xref: /external/chromium_org/components/policy/core/common/cloud/external_policy_data_fetcher.h

// Copyright 2013 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_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_FETCHER_H_
#define COMPONENTS_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_FETCHER_H_

#include <map>
#include <set>
#include <string>

#include "base/basictypes.h"
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/memory/weak_ptr.h"
#include "components/policy/policy_export.h"
#include "net/url_request/url_fetcher_delegate.h"
#include "url/gurl.h"

namespace base {
class SequencedTaskRunner;
}

namespace net {
class URLFetcher;
class URLRequestContextGetter;
}

namespace policy {

class ExternalPolicyDataFetcherBackend;

// This class handles network fetch jobs for the ExternalPolicyDataUpdater by
// forwarding them to an ExternalPolicyDataFetcherBackend running on a different
// thread. This is necessary because the ExternalPolicyDataUpdater runs on a
// background thread where network I/O is not allowed.
// The class can be instantiated on any thread but from then on, it must be
// accessed and destroyed on the background thread that the
// ExternalPolicyDataUpdater runs on only.
class POLICY_EXPORT ExternalPolicyDataFetcher {
 public:
  // The result of a fetch job.
  enum Result {
    // Successful fetch.
    SUCCESS,
    // The connection was interrupted.
    CONNECTION_INTERRUPTED,
    // Another network error occurred.
    NETWORK_ERROR,
    // Problem at the server.
    SERVER_ERROR,
    // Client error.
    CLIENT_ERROR,
    // Any other type of HTTP failure.
    HTTP_ERROR,
    // Received data exceeds maximum allowed size.
    MAX_SIZE_EXCEEDED,
  };

  // Encapsulates the metadata for a fetch job.
  struct Job;

  // Callback invoked when a fetch job finishes. If the fetch was successful,
  // the Result is SUCCESS and the scoped_ptr contains the retrieved data.
  // Otherwise, Result indicates the type of error that occurred and the
  // scoped_ptr is NULL.
  typedef base::Callback<void(Result, scoped_ptr<std::string>)> FetchCallback;

  // |task_runner| represents the background thread that |this| runs on.
  // |backend| is used to perform network I/O. It will be dereferenced and
  // accessed via |io_task_runner| only.
  ExternalPolicyDataFetcher(
      scoped_refptr<base::SequencedTaskRunner> task_runner,
      scoped_refptr<base::SequencedTaskRunner> io_task_runner,
      const base::WeakPtr<ExternalPolicyDataFetcherBackend>& backend);
  ~ExternalPolicyDataFetcher();

  // Fetch data from |url| and invoke |callback| with the result. See the
  // documentation of FetchCallback and Result for more details. If a fetch
  // should be retried after an error, it is the caller's responsibility to call
  // StartJob() again. Returns an opaque job identifier. Ownership of the job
  // identifier is retained by |this|.
  Job* StartJob(const GURL& url,
                int64 max_size,
                const FetchCallback& callback);

  // Cancel the fetch job identified by |job|. The job is canceled silently,
  // without invoking the |callback| that was passed to StartJob().
  void CancelJob(Job* job);

 private:
  // Callback invoked when a fetch job finishes in the |backend_|.
  void OnJobFinished(const FetchCallback& callback,
                     Job* job,
                     Result result,
                     scoped_ptr<std::string> data);

  // Task runner representing the thread that |this| runs on.
  scoped_refptr<base::SequencedTaskRunner> task_runner_;

  // Task runner representing the thread on which the |backend_| runs and
  // performs network I/O.
  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;

  // The |backend_| is used to perform network I/O. It may be dereferenced and
  // accessed via |io_task_runner_| only.
  base::WeakPtr<ExternalPolicyDataFetcherBackend> backend_;

  // Set that owns all currently running Jobs.
  typedef std::set<Job*> JobSet;
  JobSet jobs_;

  base::WeakPtrFactory<ExternalPolicyDataFetcher> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataFetcher);
};

// This class handles network I/O for one or more ExternalPolicyDataFetchers. It
// can be instantiated on any thread that is allowed to reference
// URLRequestContextGetters (in Chrome, these are the UI and IO threads) and
// CreateFrontend() may be called from the same thread after instantiation. From
// then on, it must be accessed and destroyed on the thread that handles network
// I/O only (in Chrome, this is the IO thread).
class POLICY_EXPORT ExternalPolicyDataFetcherBackend
    : public net::URLFetcherDelegate {
 public:
  // Callback invoked when a fetch job finishes. If the fetch was successful,
  // the Result is SUCCESS and the scoped_ptr contains the retrieved data.
  // Otherwise, Result indicates the type of error that occurred and the
  // scoped_ptr is NULL.
  typedef base::Callback<void(ExternalPolicyDataFetcher::Job*,
                              ExternalPolicyDataFetcher::Result,
                              scoped_ptr<std::string>)> FetchCallback;

  // |io_task_runner_| represents the thread that handles network I/O and that
  // |this| runs on. |request_context| is used to construct URLFetchers.
  ExternalPolicyDataFetcherBackend(
      scoped_refptr<base::SequencedTaskRunner> io_task_runner,
      scoped_refptr<net::URLRequestContextGetter> request_context);
  virtual ~ExternalPolicyDataFetcherBackend();

  // Create an ExternalPolicyDataFetcher that allows fetch jobs to be started
  // from the thread represented by |task_runner|.
  scoped_ptr<ExternalPolicyDataFetcher> CreateFrontend(
      scoped_refptr<base::SequencedTaskRunner> task_runner);

  // Start a fetch job defined by |job|. The caller retains ownership of |job|
  // and must ensure that it remains valid until the job ends, CancelJob() is
  // called or |this| is destroyed.
  void StartJob(ExternalPolicyDataFetcher::Job* job);

  // Cancel the fetch job defined by |job| and invoke |callback| to confirm.
  void CancelJob(ExternalPolicyDataFetcher::Job* job,
                 const base::Closure& callback);

  // net::URLFetcherDelegate:
  virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
  virtual void OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                          int64 current,
                                          int64 total) OVERRIDE;

 private:
  scoped_refptr<base::SequencedTaskRunner> io_task_runner_;
  scoped_refptr<net::URLRequestContextGetter> request_context_;

  // A monotonically increasing fetch ID. Used to identify fetches in tests.
  int last_fetch_id_;

  // Map that owns the net::URLFetchers for all currently running jobs and maps
  // from these to the corresponding Job.
  typedef std::map<net::URLFetcher*, ExternalPolicyDataFetcher::Job*> JobMap;
  JobMap job_map_;

  base::WeakPtrFactory<ExternalPolicyDataFetcherBackend> weak_factory_;

  DISALLOW_COPY_AND_ASSIGN(ExternalPolicyDataFetcherBackend);
};


}  // namespace policy

#endif  // COMPONENTS_POLICY_CORE_COMMON_CLOUD_EXTERNAL_POLICY_DATA_FETCHER_H_