gecko-dev/dom/plugins/ipc/BrowserStreamChild.h

/* -*- Mode: C++; c-basic-offset: 2; indent-tabs-mode: nil; tab-width: 8 -*- */
/* 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_plugins_BrowserStreamChild_h
#define mozilla_plugins_BrowserStreamChild_h 1

#include "mozilla/plugins/PBrowserStreamChild.h"
#include "mozilla/plugins/AStream.h"
#include "base/task.h"
#include "base/timer.h"

namespace mozilla {
namespace plugins {

class PluginInstanceChild;
class StreamNotifyChild;

class BrowserStreamChild : public PBrowserStreamChild, public AStream {
 public:
  BrowserStreamChild(PluginInstanceChild* instance, const nsCString& url,
                     const uint32_t& length, const uint32_t& lastmodified,
                     StreamNotifyChild* notifyData, const nsCString& headers);
  virtual ~BrowserStreamChild();

  virtual bool IsBrowserStream() override { return true; }

  NPError StreamConstructed(const nsCString& mimeType, const bool& seekable,
                            uint16_t* stype);

  virtual mozilla::ipc::IPCResult RecvWrite(const int32_t& offset,
                                            const uint32_t& newsize,
                                            const Buffer& data) override;
  virtual mozilla::ipc::IPCResult RecvNPP_DestroyStream(
      const NPReason& reason) override;
  virtual mozilla::ipc::IPCResult Recv__delete__() override;

  void EnsureCorrectInstance(PluginInstanceChild* i) {
    if (i != mInstance) MOZ_CRASH("Incorrect stream instance");
  }
  void EnsureCorrectStream(NPStream* s) {
    if (s != &mStream) MOZ_CRASH("Incorrect stream data");
  }

  void NotifyPending() {
    NS_ASSERTION(!mNotifyPending, "Pending twice?");
    mNotifyPending = true;
    EnsureDeliveryPending();
  }

  /**
   * During instance destruction, artificially cancel all outstanding streams.
   *
   * @return false if we are already in the DELETING state.
   */
  bool InstanceDying() {
    if (DELETING == mState) return false;

    mInstanceDying = true;
    return true;
  }

  void FinishDelivery() {
    NS_ASSERTION(mInstanceDying, "Should only be called after InstanceDying");
    NS_ASSERTION(DELETING != mState, "InstanceDying didn't work?");
    mStreamStatus = NPRES_USER_BREAK;
    Deliver();
    NS_ASSERTION(!mStreamNotify, "Didn't deliver NPN_URLNotify?");
  }

 private:
  friend class StreamNotifyChild;

  /**
   * Post an event to ensure delivery of pending data/destroy/urlnotify events
   * outside of the current RPC stack.
   */
  void EnsureDeliveryPending();

  /**
   * Deliver data, destruction, notify scheduling
   * or cancelling the suspended timer as needed.
   */
  void Deliver();

  /**
   * Deliver one chunk of pending data.
   * @return true if the plugin indicated a pause was necessary
   */
  bool DeliverPendingData();

  void SetSuspendedTimer();
  void ClearSuspendedTimer();

  PluginInstanceChild* mInstance;
  NPStream mStream;

  static const NPReason kStreamOpen = -1;

  /**
   * The plugin's notion of whether a stream has been "closed" (no more
   * data delivery) differs from the plugin host due to asynchronous delivery
   * of data and stream destruction. While the plugin-visible stream is open,
   * mStreamStatus should be kStreamOpen (-1). mStreamStatus will be a
   * failure code if either the parent or child indicates stream failure.
   */
  NPReason mStreamStatus;

  /**
   * Delivery of NPP_DestroyStream and NPP_URLNotify must be postponed until
   * all data has been delivered.
   */
  enum {
    NOT_DESTROYED,    // NPP_DestroyStream not yet received
    DESTROY_PENDING,  // NPP_DestroyStream received, not yet delivered
    DESTROYED         // NPP_DestroyStream delivered, NPP_URLNotify may still be
                      // pending
  } mDestroyPending;
  bool mNotifyPending;

  // When NPP_Destroy is called for our instance (manager), this flag is set
  // cancels the stream and avoids sending StreamDestroyed.
  bool mInstanceDying;

  enum { CONSTRUCTING, ALIVE, DYING, DELETING } mState;
  nsCString mURL;
  nsCString mHeaders;
  StreamNotifyChild* mStreamNotify;

  struct PendingData {
    int32_t offset;
    Buffer data;
    int32_t curpos;
  };
  nsTArray<PendingData> mPendingData;

  /**
   * Asynchronous RecvWrite messages are never delivered to the plugin
   * immediately, because that may be in the midst of an unexpected RPC
   * stack frame. It instead posts a runnable using this tracker to cancel
   * in case we are destroyed.
   */
  ScopedRunnableMethodFactory<BrowserStreamChild> mDeliveryTracker;
  base::RepeatingTimer<BrowserStreamChild> mSuspendedTimer;
};

}  // namespace plugins
}  // namespace mozilla

#endif /* mozilla_plugins_BrowserStreamChild_h */