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
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
// HttpLog.h should generally be included first
#include "HttpLog.h"
#include "SpeculativeTransaction.h"
#include "HTTPSRecordResolver.h"
#include "nsICachingChannel.h"
#include "nsHttpHandler.h"
namespace mozilla {
namespace net {
SpeculativeTransaction::SpeculativeTransaction(
nsHttpConnectionInfo* aConnInfo, nsIInterfaceRequestor* aCallbacks,
uint32_t aCaps, std::function<void(bool)>&& aCallback)
: NullHttpTransaction(aConnInfo, aCallbacks, aCaps),
mCloseCallback(std::move(aCallback)) {}
SpeculativeTransaction::~SpeculativeTransaction() = default;
already_AddRefed<SpeculativeTransaction>
SpeculativeTransaction::CreateWithNewConnInfo(nsHttpConnectionInfo* aConnInfo) {
RefPtr<SpeculativeTransaction> trans =
new SpeculativeTransaction(aConnInfo, mCallbacks, mCaps);
trans->mParallelSpeculativeConnectLimit = mParallelSpeculativeConnectLimit;
trans->mIgnoreIdle = mIgnoreIdle;
trans->mIsFromPredictor = mIsFromPredictor;
trans->mAllow1918 = mAllow1918;
return trans.forget();
}
nsresult SpeculativeTransaction::FetchHTTPSRR() {
LOG(("SpeculativeTransaction::FetchHTTPSRR [this=%p]", this));
MOZ_ASSERT(OnSocketThread(), "not on socket thread");
mResolver = new HTTPSRecordResolver(this);
nsCOMPtr<nsICancelable> dnsRequest;
nsresult rv = mResolver->FetchHTTPSRRInternal(GetCurrentSerialEventTarget(),
getter_AddRefs(dnsRequest));
if (NS_FAILED(rv)) {
mResolver->Close();
mResolver = nullptr;
}
return rv;
}
nsresult SpeculativeTransaction::OnHTTPSRRAvailable(
nsIDNSHTTPSSVCRecord* aHTTPSSVCRecord,
nsISVCBRecord* aHighestPriorityRecord, const nsACString& aCname) {
MOZ_ASSERT(OnSocketThread(), "not on socket thread");
LOG(("SpeculativeTransaction::OnHTTPSRRAvailable [this=%p]", this));
RefPtr<HTTPSRecordResolver> resolver = std::move(mResolver);
if (!aHTTPSSVCRecord || !aHighestPriorityRecord) {
gHttpHandler->ConnMgr()->DoSpeculativeConnection(this, false);
return NS_OK;
}
RefPtr<nsHttpConnectionInfo> connInfo = ConnectionInfo();
RefPtr<nsHttpConnectionInfo> newInfo =
connInfo->CloneAndAdoptHTTPSSVCRecord(aHighestPriorityRecord);
RefPtr<SpeculativeTransaction> newTrans = CreateWithNewConnInfo(newInfo);
gHttpHandler->ConnMgr()->DoSpeculativeConnection(newTrans, false);
return NS_OK;
}
nsresult SpeculativeTransaction::ReadSegments(nsAHttpSegmentReader* aReader,
uint32_t aCount,
uint32_t* aCountRead) {
MOZ_ASSERT(OnSocketThread(), "not on socket thread");
mTriedToWrite = true;
return NullHttpTransaction::ReadSegments(aReader, aCount, aCountRead);
}
void SpeculativeTransaction::Close(nsresult aReason) {
MOZ_ASSERT(OnSocketThread(), "not on socket thread");
LOG(("SpeculativeTransaction::Close %p aReason=%" PRIx32, this,
static_cast<uint32_t>(aReason)));
NullHttpTransaction::Close(aReason);
if (mResolver) {
mResolver->Close();
mResolver = nullptr;
}
if (aReason == NS_BASE_STREAM_CLOSED) {
aReason = NS_OK;
}
if (mCloseCallback) {
mCloseCallback(mTriedToWrite && NS_SUCCEEDED(aReason));
mCloseCallback = nullptr;
}
}
void SpeculativeTransaction::InvokeCallback() {
if (mCloseCallback) {
mCloseCallback(true);
mCloseCallback = nullptr;
}
}
} // namespace net
} // namespace mozilla
|
