/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 : */

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_net_HttpBackgroundChannelChild_h
#define mozilla_net_HttpBackgroundChannelChild_h

#include "mozilla/net/PHttpBackgroundChannelChild.h"
#include "mozilla/ipc/Endpoint.h"
#include "nsIRunnable.h"
#include "nsTArray.h"

using mozilla::ipc::IPCResult;

namespace mozilla {
namespace net {

class PBackgroundDataBridgeChild;
class BackgroundDataBridgeChild;
class HttpChannelChild;

class HttpBackgroundChannelChild final : public PHttpBackgroundChannelChild {
  friend class BackgroundChannelCreateCallback;
  friend class PHttpBackgroundChannelChild;
  friend class HttpChannelChild;
  friend class BackgroundDataBridgeChild;

 public:
  explicit HttpBackgroundChannelChild();

  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(HttpBackgroundChannelChild, final)

  // Associate this background channel with a HttpChannelChild and
  // initiate the createion of the PBackground IPC channel.
  nsresult Init(HttpChannelChild* aChannelChild);

  // Callback while the associated HttpChannelChild is not going to
  // handle any incoming messages over background channel.
  void OnChannelClosed();

  // Return true if OnChannelClosed has been called.
  bool ChannelClosed();

  // Callback when OnStartRequest is received and handled by HttpChannelChild.
  // Enqueued messages in background channel will be flushed.
  void OnStartRequestReceived(Maybe<uint32_t> aMultiPartID);

#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED
  bool IsQueueEmpty() const { return mQueuedRunnables.IsEmpty(); }
#endif

 protected:
  IPCResult RecvOnStartRequest(const nsHttpResponseHead& aResponseHead,
                               const bool& aUseResponseHead,
                               const nsHttpHeaderArray& aRequestHeaders,
                               const HttpChannelOnStartRequestArgs& aArgs,
                               const HttpChannelAltDataStream& aAltData,
                               const TimeStamp& aOnStartRequestStart);

  IPCResult RecvOnTransportAndData(const nsresult& aChannelStatus,
                                   const nsresult& aTransportStatus,
                                   const uint64_t& aOffset,
                                   const uint32_t& aCount,
                                   const nsACString& aData,
                                   const bool& aDataFromSocketProcess,
                                   const TimeStamp& aOnDataAvailableStart);

  IPCResult RecvOnStopRequest(
      const nsresult& aChannelStatus, const ResourceTimingStructArgs& aTiming,
      const TimeStamp& aLastActiveTabOptHit,
      const nsHttpHeaderArray& aResponseTrailers,
      nsTArray<ConsoleReportCollected>&& aConsoleReports,
      const bool& aFromSocketProcess, const TimeStamp& aOnStopRequestStart);

  IPCResult RecvOnConsoleReport(
      nsTArray<ConsoleReportCollected>&& aConsoleReports);

  IPCResult RecvOnAfterLastPart(const nsresult& aStatus);

  IPCResult RecvOnProgress(const int64_t& aProgress,
                           const int64_t& aProgressMax);

  IPCResult RecvOnStatus(const nsresult& aStatus);

  IPCResult RecvNotifyClassificationFlags(const uint32_t& aClassificationFlags,
                                          const bool& aIsThirdParty);

  IPCResult RecvSetClassifierMatchedInfo(const ClassifierInfo& info);

  IPCResult RecvSetClassifierMatchedTrackingInfo(const ClassifierInfo& info);

  IPCResult RecvAttachStreamFilter(
      Endpoint<extensions::PStreamFilterParent>&& aEndpoint);

  IPCResult RecvDetachStreamFilters();

  void ActorDestroy(ActorDestroyReason aWhy) override;

  void CreateDataBridge(Endpoint<PBackgroundDataBridgeChild>&& aEndpoint);

 private:
  virtual ~HttpBackgroundChannelChild();

  // Initiate the creation of the PBckground IPC channel.
  // Return false if failed.
  bool CreateBackgroundChannel();

  // Check OnStartRequest is sent by parent process over main thread IPC
  // but not yet received on child process.
  // return true before RecvOnStartRequestSent is invoked.
  // return false if RecvOnStartRequestSent is invoked but not
  // OnStartRequestReceived.
  // return true after both RecvOnStartRequestSend and OnStartRequestReceived
  // are invoked.
  bool IsWaitingOnStartRequest();

  // Associated HttpChannelChild for handling the channel events.
  // Will be removed while failed to create background channel,
  // destruction of the background channel, or explicitly dissociation
  // via OnChannelClosed callback.
  RefPtr<HttpChannelChild> mChannelChild;

  // True if OnStartRequest is received by HttpChannelChild.
  // Should only access on STS thread.
  bool mStartReceived = false;

  // Store pending messages that require to be handled after OnStartRequest.
  // Should be flushed after OnStartRequest is received and handled.
  // Should only access on STS thread.
  nsTArray<nsCOMPtr<nsIRunnable>> mQueuedRunnables;

  enum ODASource {
    ODA_PENDING = 0,      // ODA is pending
    ODA_FROM_PARENT = 1,  // ODA from parent process.
    ODA_FROM_SOCKET = 2   // response coming from the network
  };
  // We need to know the first ODA will be from socket process or parent
  // process. This information is from OnStartRequest message from parent
  // process.
  ODASource mFirstODASource;

  // Indicate whether HttpChannelChild::ProcessOnStopRequest is called.
  bool mOnStopRequestCalled = false;

  // This is used when we receive the console report from parent process, but
  // still not get the OnStopRequest from socket process.
  std::function<void()> mConsoleReportTask;
};

}  // namespace net
}  // namespace mozilla

#endif  // mozilla_net_HttpBackgroundChannelChild_h