// Copyright 2019 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 THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PORTAL_PORTAL_CONTENTS_H_
#define THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PORTAL_PORTAL_CONTENTS_H_

#include "base/memory/scoped_refptr.h"
#include "base/optional.h"
#include "mojo/public/cpp/bindings/associated_receiver.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "mojo/public/cpp/bindings/pending_associated_receiver.h"
#include "mojo/public/cpp/bindings/pending_associated_remote.h"
#include "services/network/public/mojom/referrer_policy.mojom-shared.h"
#include "third_party/blink/public/common/tokens/tokens.h"
#include "third_party/blink/public/mojom/portal/portal.mojom-blink.h"
#include "third_party/blink/renderer/platform/heap/garbage_collected.h"

namespace blink {

class Document;
class HTMLPortalElement;
class KURL;
class PortalActivationDelegate;
class RemoteFrame;
class SecurityOrigin;
struct BlinkTransferableMessage;

// The contents of an HTMLPortalElement, corresponding to ownership of a
// content::WebContents.
//
// This object is usually owned by an HTMLPortalElement but may be briefly owned
// elsewhere. For example, during activation it is necessary to keep the Mojo
// connection to the browser-side portal state alive (so that the reply can be
// received), but this should not prevent the <portal> element from being reused
// in the meantime.
class PortalContents : public GarbageCollected<PortalContents>,
                       public mojom::blink::PortalClient {
 public:
  PortalContents(
      HTMLPortalElement& portal_element,
      const PortalToken& portal_token,
      mojo::PendingAssociatedRemote<mojom::blink::Portal> remote_portal,
      mojo::PendingAssociatedReceiver<mojom::blink::PortalClient>
          portal_client_receiver);
  ~PortalContents() override;

  // Returns true if this object corresponds to an existent portal contents.
  bool IsValid() const { return remote_portal_.is_bound(); }

  // Returns true if this contents is currently being activated.
  bool IsActivating() const { return activation_delegate_; }

  // Returns an unguessable token which uniquely identifies the contents, if
  // valid.
  const base::Optional<PortalToken>& GetToken() const { return portal_token_; }

  // Returns the RemoteFrame associated with this portal, if any.
  RemoteFrame* GetFrame() const;

  // Activates the portal contents, and produces a promise which resolves when
  // complete. The caller is expected to do all necessary preflight checks in
  // advance.
  void Activate(BlinkTransferableMessage data, PortalActivationDelegate*);

  // Posts a message which will be delivered in the guest contents via the
  // PortalHost object.
  void PostMessageToGuest(BlinkTransferableMessage message);

  // Request navigation to the specified URL. May be a no-op if navigation to
  // this URL is not permitted.
  void Navigate(const KURL&, network::mojom::ReferrerPolicy);

  // Tears down the internal state of this object. If ownership has not been
  // transferred (via adoption), then the underlying contents will also be torn
  // down.
  void Destroy();

  // Called when the connection to the browser-side Portal object is lost.
  // Cleans up any remaining state.
  void DisconnectHandler();

  // blink::mojom::PortalClient implementation
  void ForwardMessageFromGuest(
      BlinkTransferableMessage message,
      const scoped_refptr<const SecurityOrigin>& source_origin) override;
  void DispatchLoadEvent() override;

  void Trace(Visitor* visitor) const;

 private:
  // Returns the document which controls the lifetime of this portal (usually,
  // the document of the HTMLPortalElement which owns this).
  Document& GetDocument() const { return *document_; }

  // Called on response to the request to activate the portal contents.
  void OnActivateResponse(mojom::blink::PortalActivateResult);

  // The document which owns this contents.
  // TODO(jbroman): Should this be a ExecutionContextLifecycleObserver instead?
  Member<Document> document_;

  // The element which owns this contents, if any. This is set to nullptr once
  // Destroy has been called.
  Member<HTMLPortalElement> portal_element_;

  // Set if the portal contents is currently being activated.
  // If so it will be the activating portal contents of the associated
  // DocumentPortals.
  Member<PortalActivationDelegate> activation_delegate_;

  // Uniquely identifies the portal. This token is used by the browser process
  // to reference this portal when communicating with the renderer. This is set
  // to base::nullopt once Destroy has been called.
  base::Optional<PortalToken> portal_token_;

  // Both of these will be reset once Destroy has been called.
  mojo::AssociatedRemote<mojom::blink::Portal> remote_portal_;
  mojo::AssociatedReceiver<mojom::blink::PortalClient> portal_client_receiver_;
};

}  // namespace blink

#endif  // THIRD_PARTY_BLINK_RENDERER_CORE_HTML_PORTAL_PORTAL_CONTENTS_H_