Source code

Revision control

Line Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/* 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/. */

#include "nsISupports.idl"

%{C++
// Forward-declare mozilla::net::SpdyPushCache
namespace mozilla {
namespace net {
class SpdyPushCache;
}
}
%}

interface nsILoadGroup;
interface nsIChannel;
interface nsIStreamListener;

[ptr] native SpdyPushCachePtr(mozilla::net::SpdyPushCache);

/**
 * Requests capable of tail-blocking must implement this
 * interfaces (typically channels).
 * If the request is tail-blocked, it will be held in its request
 * context queue until unblocked.
 */
[scriptable, uuid(7EB361D4-37A5-42C9-AFAE-F6C88FE7C394)]
interface nsIRequestTailUnblockCallback : nsISupports
{
  /**
   * Called when the requests is unblocked and proceed.
   * @param result
   *    NS_OK - the request is OK to go, unblocking is not
   *            caused by cancelation of the request.
   *    any error - the request must behave as it were canceled
   *                with the result as status.
   */
  void onTailUnblock(in nsresult aResult);
};

/**
 * The nsIRequestContext is used to maintain state about connections
 * that are in some way associated with each other (often by being part
 * of the same load group) and how they interact with blocking items like
 * HEAD css/js loads.
 *
 * This used to be known as nsILoadGroupConnectionInfo and nsISchedulingContext.
 */
[scriptable, uuid(658e3e6e-8633-4b1a-8d66-fa9f72293e63)]
interface nsIRequestContext : nsISupports
{
  /**
   * A unique identifier for this request context
   */
  [notxpcom, nostdcall] readonly attribute unsigned long long ID;

  /**
   * Called by the associated document when its load starts.  This resets
   * context's internal states.
   */
  void beginLoad();

  /**
  * Called when the associated document notified the DOMContentLoaded event.
  */
  void DOMContentLoaded();

  /**
   * Number of active blocking transactions associated with this context
   */
  readonly attribute unsigned long blockingTransactionCount;

  /**
   * Increase the number of active blocking transactions associated
   * with this context by one.
   */
  void addBlockingTransaction();

  /**
   * Decrease the number of active blocking transactions associated
   * with this context by one. The return value is the number of remaining
   * blockers.
   */
  unsigned long removeBlockingTransaction();

  /**
   * This gives out a weak pointer to the push cache.
   * The nsIRequestContext implementation owns the cache
   * and will destroy it when overwritten or when the context
   * ends.
   */
  [notxpcom,nostdcall] attribute SpdyPushCachePtr spdyPushCache;

  /**
   * This holds a cached value of the user agent override.
   */
  [notxpcom,nostdcall] attribute ACString userAgentOverride;

  /**
   * Increases/decrease the number of non-tailed requests in this context.
   * If the count drops to zero, all tail-blocked callbacks are notified
   * shortly after that to be unblocked.
   */
  void addNonTailRequest();
  void removeNonTailRequest();

  /**
   * If the request context is in tail-blocked state, the callback
   * is queued and result is true.  The callback will be notified
   * about tail-unblocking or when the request context is canceled.
   */
  [must_use] boolean isContextTailBlocked(in nsIRequestTailUnblockCallback callback);

  /**
   * Called when the request is sitting in the tail queue but has been
   * canceled before untailing.  This just removes the request from the
   * queue so that it is not notified on untail and not referenced.
   */
  void cancelTailedRequest(in nsIRequestTailUnblockCallback request);

  /**
   * This notifies all queued tail-blocked requests, they will be notified
   * aResult and released afterwards.  Called by the load group when
   * it's canceled.
   */
  void cancelTailPendingRequests(in nsresult aResult);
};

/**
 * The nsIRequestContextService is how anyone gets access to a request
 * context when they haven't been explicitly given a strong reference to an
 * existing one. It is responsible for creating and handing out strong
 * references to nsIRequestContexts, but only keeps weak references itself.
 * The shared request context will go away once no one else is keeping a
 * reference to it. If you ask for a request context that has no one else
 * holding a reference to it, you'll get a brand new request context. Anyone
 * who asks for the same request context while you're holding a reference
 * will get a reference to the same request context you have.
 */
[uuid(7fcbf4da-d828-4acc-b144-e5435198f727)]
interface nsIRequestContextService : nsISupports
{
  /**
   * Get an existing request context from its ID
   */
  nsIRequestContext getRequestContext(in unsigned long long id);
  /**
   * Shorthand to get request context from a load group
   */
  nsIRequestContext getRequestContextFromLoadGroup(in nsILoadGroup lg);

  /**
   * Create a new request context
   */
  nsIRequestContext newRequestContext();

  /**
   * Remove an existing request context from its ID
   */
  void removeRequestContext(in unsigned long long id);
};