// Copyright 2017 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 CONTENT_BROWSER_URL_LOADER_FACTORY_GETTER_H_
#define CONTENT_BROWSER_URL_LOADER_FACTORY_GETTER_H_

#include <memory>

#include "base/callback_forward.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "content/common/content_export.h"
#include "content/public/browser/browser_thread.h"
#include "services/network/public/mojom/url_loader_factory.mojom.h"

namespace network {
class SharedURLLoaderFactoryInfo;
class SharedURLLoaderFactory;
}  // namespace network

namespace content {

class StoragePartitionImpl;

// Holds on to URLLoaderFactory for a given StoragePartition and allows code
// running on the IO thread to access them. Note these are the factories used by
// the browser process for frame requests.
class URLLoaderFactoryGetter
    : public base::RefCountedThreadSafe<URLLoaderFactoryGetter,
                                        BrowserThread::DeleteOnIOThread> {
 public:
  CONTENT_EXPORT URLLoaderFactoryGetter();

  // Initializes this object on the UI thread. The |partition| is used to
  // initialize the URLLoaderFactories for the network service, AppCache, and
  // ServiceWorkers, and will be cached to recover from connection error.
  // After Initialize(), you can get URLLoaderFactories from this
  // getter. However, any messages on it will be queued until
  // HandleFactoryRequests() is called.
  void Initialize(StoragePartitionImpl* partition);

  // Called on the UI thread to actually instantiate factories whose pointers
  // are to be exposed by this getter.  This must be called after NetworkContext
  // is initialized.
  // TODO(shimazu): Remove this once NetworkService is shipped.
  void HandleFactoryRequests();

  // Clear the cached pointer to |StoragePartitionImpl| on the UI thread. Should
  // be called when the partition is going away.
  void OnStoragePartitionDestroyed();

  // Called on the IO thread to get a shared wrapper to this
  // URLLoaderFactoryGetter, which can be used to access the URLLoaderFactory
  // to the network service and supports auto-reconnect after crash.
  CONTENT_EXPORT scoped_refptr<network::SharedURLLoaderFactory>
  GetNetworkFactory();

  // Like above, except it returns a URLLoaderFactory that has CORB enabled. Use
  // this when using the factory for requests on behalf of a renderer.
  // TODO(lukasza): https://crbug.com/871827: Ensure that |request_initiator| is
  // trustworthy, even when starting requests on behalf of a renderer.
  CONTENT_EXPORT scoped_refptr<network::SharedURLLoaderFactory>
  GetNetworkFactoryWithCORBEnabled();

  // Called on the UI thread to get an info that holds a reference to this
  // URLLoaderFactoryGetter, which can be used to construct a similar
  // SharedURLLoaderFactory as returned from |GetNetworkFactory()| on IO thread.
  CONTENT_EXPORT std::unique_ptr<network::SharedURLLoaderFactoryInfo>
  GetNetworkFactoryInfo();

  // Called on the IO thread. The factory obtained from here can only be used
  // from the browser process. It must NOT be sent to a renderer process. It has
  // CORB disabled, so it must NOT be used to make requests on behalf of a
  // renderer.
  //
  // When NetworkService is enabled, this clones the internal factory to the
  // network service, which doesn't support auto-reconnect after crash. Useful
  // for one-off requests (e.g. a single navigation) to avoid an additional Mojo
  // hop.
  //
  // When NetworkService is disabled, this clones the non-NetworkService direct
  // network factory.
  CONTENT_EXPORT void CloneNetworkFactory(
      network::mojom::URLLoaderFactoryRequest network_factory_request);

  // Overrides the network URLLoaderFactory for subsequent requests. Passing a
  // null pointer will restore the default behavior.
  CONTENT_EXPORT void SetNetworkFactoryForTesting(
      network::mojom::URLLoaderFactory* test_factory,
      bool is_corb_enabled = false);

  CONTENT_EXPORT network::mojom::URLLoaderFactoryPtr*
  original_network_factory_for_testing() {
    return &network_factory_;
  }

  CONTENT_EXPORT network::mojom::URLLoaderFactoryPtr*
  original_network_factory__corb_enabled_for_testing() {
    return &network_factory_corb_enabled_;
  }

  // When this global function is set, if GetURLLoaderFactory is called and
  // |test_factory_| is null, then the callback will be run. This method must be
  // called either on the IO thread or before threads start. This callback is
  // run on the IO thread.
  using GetNetworkFactoryCallback = base::RepeatingCallback<void(
      URLLoaderFactoryGetter* url_loader_factory_getter)>;
  CONTENT_EXPORT static void SetGetNetworkFactoryCallbackForTesting(
      const GetNetworkFactoryCallback& get_network_factory_callback);

  // Call |network_factory_.FlushForTesting()| on IO thread. For test use only.
  CONTENT_EXPORT void FlushNetworkInterfaceOnIOThreadForTesting();

 private:
  class URLLoaderFactoryForIOThreadInfo;
  class URLLoaderFactoryForIOThread;

  friend class base::DeleteHelper<URLLoaderFactoryGetter>;
  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;

  CONTENT_EXPORT ~URLLoaderFactoryGetter();
  void InitializeOnIOThread(
      network::mojom::URLLoaderFactoryPtrInfo network_factory);

  // Moves |network_factory| to |network_factory_| or
  // |network_factory_corb_enabled_| depending on |is_corb_enabled| and sets up
  // an error handler.
  void ReinitializeOnIOThread(
      network::mojom::URLLoaderFactoryPtr network_factory,
      bool is_corb_enabled);

  // Send |network_factory_request| to cached |StoragePartitionImpl|.
  void HandleNetworkFactoryRequestOnUIThread(
      network::mojom::URLLoaderFactoryRequest network_factory_request,
      bool is_corb_enabled);

  // Called on the IO thread to get the URLLoaderFactory to the network service.
  // The pointer shouldn't be cached.
  network::mojom::URLLoaderFactory* GetURLLoaderFactory(bool is_corb_enabled);

  // Call |network_factory_.FlushForTesting()|. For test use only. When the
  // flush is complete, |callback| will be called.
  void FlushNetworkInterfaceForTesting(base::OnceClosure callback);

  // Bound with appropriate URLLoaderFactories at HandleFactoryRequests().
  network::mojom::URLLoaderFactoryRequest pending_network_factory_request_;

  // Only accessed on IO thread.
  network::mojom::URLLoaderFactoryPtr network_factory_;
  network::mojom::URLLoaderFactoryPtr network_factory_corb_enabled_;
  network::mojom::URLLoaderFactory* test_factory_ = nullptr;
  network::mojom::URLLoaderFactory* test_factory_corb_enabled_ = nullptr;

  // Used to re-create |network_factory_| when connection error happens. Can
  // only be accessed on UI thread. Must be cleared by |StoragePartitionImpl|
  // when it's going away.
  StoragePartitionImpl* partition_ = nullptr;

  DISALLOW_COPY_AND_ASSIGN(URLLoaderFactoryGetter);
};

}  // namespace content

#endif  // CONTENT_BROWSER_URL_LOADER_FACTORY_GETTER_H_