/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp

Bug Summary

File:	var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp
Warning:	line 2392, column 3 Value stored to 'pos' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name Unified_cpp_netwerk_cache20.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/netwerk/cache2 -fcoverage-compilation-dir=/var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/netwerk/cache2 -resource-dir /usr/lib/llvm-18/lib/clang/18 -include /var/lib/jenkins/workspace/firefox-scan-build/config/gcc_hidden.h -include /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/mozilla-config.h -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/stl_wrappers -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D MOZ_HAS_MOZGLUE -D MOZILLA_INTERNAL_API -D IMPL_LIBXUL -D MOZ_SUPPORT_LEAKCHECKING -D STATIC_EXPORTABLE_JS_API -I /var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2 -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/netwerk/cache2 -I /var/lib/jenkins/workspace/firefox-scan-build/netwerk/base -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/ipc/ipdl/_ipdlheaders -I /var/lib/jenkins/workspace/firefox-scan-build/ipc/chromium/src -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /var/lib/jenkins/workspace/firefox-scan-build/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/x86_64-linux-gnu/c++/14 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../include/c++/14/backward -internal-isystem /usr/lib/llvm-18/lib/clang/18/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/14/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-deprecated-this-capture -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -fdeprecated-macro -ferror-limit 19 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fno-rtti -fgnuc-version=4.2.1 -fno-aligned-allocation -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2024-07-21-021012-413605-1 -x c++ Unified_cpp_netwerk_cache20.cpp

1	/* This Source Code Form is subject to the terms of the Mozilla Public
2	* License, v. 2.0. If a copy of the MPL was not distributed with this
3	* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
4
5	#include "CacheIndex.h"
6
7	#include "CacheLog.h"
8	#include "CacheFileIOManager.h"
9	#include "CacheFileMetadata.h"
10	#include "CacheFileUtils.h"
11	#include "CacheIndexIterator.h"
12	#include "CacheIndexContextIterator.h"
13	#include "nsThreadUtils.h"
14	#include "nsISizeOf.h"
15	#include "nsPrintfCString.h"
16	#include "mozilla/DebugOnly.h"
17	#include "prinrval.h"
18	#include "nsIFile.h"
19	#include "nsITimer.h"
20	#include "mozilla/AutoRestore.h"
21	#include <algorithm>
22	#include "mozilla/StaticPrefs_network.h"
23	#include "mozilla/Telemetry.h"
24	#include "mozilla/Unused.h"
25
26	#define kMinUnwrittenChanges300 300
27	#define kMinDumpInterval20000 20000 // in milliseconds
28	#define kMaxBufSize16384 16384
29	#define kIndexVersion0x0000000A 0x0000000A
30	#define kUpdateIndexStartDelay50000 50000 // in milliseconds
31	#define kTelemetryReportBytesLimit(2U * 1024U * 1024U * 1024U) (2U * 1024U * 1024U * 1024U) // 2GB
32
33	#define INDEX_NAME"index" "index"
34	#define TEMP_INDEX_NAME"index.tmp" "index.tmp"
35	#define JOURNAL_NAME"index.log" "index.log"
36
37	namespace mozilla::net {
38
39	namespace {
40
41	class FrecencyComparator {
42	public:
43	bool Equals(const RefPtr<CacheIndexRecordWrapper>& a,
44	const RefPtr<CacheIndexRecordWrapper>& b) const {
45	if (!a \|\| !b) {
46	return false;
47	}
48
49	return a->Get()->mFrecency == b->Get()->mFrecency;
50	}
51	bool LessThan(const RefPtr<CacheIndexRecordWrapper>& a,
52	const RefPtr<CacheIndexRecordWrapper>& b) const {
53	// Removed (=null) entries must be at the end of the array.
54	if (!a) {
55	return false;
56	}
57	if (!b) {
58	return true;
59	}
60
61	// Place entries with frecency 0 at the end of the non-removed entries.
62	if (a->Get()->mFrecency == 0) {
63	return false;
64	}
65	if (b->Get()->mFrecency == 0) {
66	return true;
67	}
68
69	return a->Get()->mFrecency < b->Get()->mFrecency;
70	}
71	};
72
73	} // namespace
74
75	// used to dispatch a wrapper deletion the caller's thread
76	// cannot be used on IOThread after shutdown begins
77	class DeleteCacheIndexRecordWrapper : public Runnable {
78	CacheIndexRecordWrapper* mWrapper;
79
80	public:
81	explicit DeleteCacheIndexRecordWrapper(CacheIndexRecordWrapper* wrapper)
82	: Runnable("net::CacheIndex::DeleteCacheIndexRecordWrapper"),
83	mWrapper(wrapper) {}
84	NS_IMETHODvirtual nsresult Run() override {
85	StaticMutexAutoLock lock(CacheIndex::sLock);
86
87	// if somehow the item is still in the frecency array, remove it
88	RefPtr<CacheIndex> index = CacheIndex::gInstance;
89	if (index) {
90	bool found = index->mFrecencyArray.RecordExistedUnlocked(mWrapper);
91	if (found) {
92	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "DeleteCacheIndexRecordWrapper::Run() - record wrapper found in frecency array during deletion" ); } } while (0)
93	("DeleteCacheIndexRecordWrapper::Run() - \do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "DeleteCacheIndexRecordWrapper::Run() - record wrapper found in frecency array during deletion" ); } } while (0)
94	record wrapper found in frecency array during deletion"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "DeleteCacheIndexRecordWrapper::Run() - record wrapper found in frecency array during deletion" ); } } while (0);
95	index->mFrecencyArray.RemoveRecord(mWrapper, lock);
96	}
97	}
98
99	delete mWrapper;
100	return NS_OK;
101	}
102	};
103
104	void CacheIndexRecordWrapper::DispatchDeleteSelfToCurrentThread() {
105	// Dispatch during shutdown will not trigger DeleteCacheIndexRecordWrapper
106	nsCOMPtr<nsIRunnable> event = new DeleteCacheIndexRecordWrapper(this);
107	MOZ_ALWAYS_SUCCEEDS(NS_DispatchToCurrentThread(event))do { if ((__builtin_expect(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl (NS_DispatchToCurrentThread(event))), 1)))), 1))) { } else { do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "NS_SUCCEEDED(NS_DispatchToCurrentThread(event))" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 107); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "false" ") (" "NS_SUCCEEDED(NS_DispatchToCurrentThread(event))" ")") ; do { ((volatile int)__null) = 107; __attribute__((nomerge )) ::abort(); } while (false); } } while (false); } } while ( false);
108	}
109
110	CacheIndexRecordWrapper::~CacheIndexRecordWrapper() {
111	#ifdef MOZ_DIAGNOSTIC_ASSERT_ENABLED1
112	CacheIndex::sLock.AssertCurrentThreadOwns();
113	RefPtr<CacheIndex> index = CacheIndex::gInstance;
114	if (index) {
115	bool found = index->mFrecencyArray.RecordExistedUnlocked(this);
116	MOZ_DIAGNOSTIC_ASSERT(!found)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!found)>::isValid, "invalid assertion condition") ; if ((__builtin_expect(!!(!(!!(!found))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!found", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 116); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "!found" ")"); do { ((volatile int)__null) = 116; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
117	}
118	#endif
119	}
120
121	/**
122	* This helper class is responsible for keeping CacheIndex::mIndexStats and
123	* CacheIndex::mFrecencyArray up to date.
124	*/
125	class MOZ_RAII CacheIndexEntryAutoManage {
126	public:
127	CacheIndexEntryAutoManage(const SHA1Sum::Hash* aHash, CacheIndex* aIndex,
128	const StaticMutexAutoLock& aProofOfLock)
129	MOZ_REQUIRES(CacheIndex::sLock)__attribute__((exclusive_locks_required(CacheIndex::sLock)))
130	: mIndex(aIndex), mProofOfLock(aProofOfLock) {
131	mHash = aHash;
132	const CacheIndexEntry* entry = FindEntry();
133	mIndex->mIndexStats.BeforeChange(entry);
134	if (entry && entry->IsInitialized() && !entry->IsRemoved()) {
135	mOldRecord = entry->mRec;
136	mOldFrecency = entry->mRec->Get()->mFrecency;
137	}
138	}
139
140	~CacheIndexEntryAutoManage() MOZ_REQUIRES(CacheIndex::sLock)__attribute__((exclusive_locks_required(CacheIndex::sLock))) {
141	const CacheIndexEntry* entry = FindEntry();
142	mIndex->mIndexStats.AfterChange(entry);
143	if (!entry \|\| !entry->IsInitialized() \|\| entry->IsRemoved()) {
144	entry = nullptr;
145	}
146
147	if (entry && !mOldRecord) {
148	mIndex->mFrecencyArray.AppendRecord(entry->mRec, mProofOfLock);
149	mIndex->AddRecordToIterators(entry->mRec, mProofOfLock);
150	} else if (!entry && mOldRecord) {
151	mIndex->mFrecencyArray.RemoveRecord(mOldRecord, mProofOfLock);
152	mIndex->RemoveRecordFromIterators(mOldRecord, mProofOfLock);
153	} else if (entry && mOldRecord) {
154	if (entry->mRec != mOldRecord) {
155	// record has a different address, we have to replace it
156	mIndex->ReplaceRecordInIterators(mOldRecord, entry->mRec, mProofOfLock);
157
158	if (entry->mRec->Get()->mFrecency == mOldFrecency) {
159	// If frecency hasn't changed simply replace the pointer
160	mIndex->mFrecencyArray.ReplaceRecord(mOldRecord, entry->mRec,
161	mProofOfLock);
162	} else {
163	// Remove old pointer and insert the new one at the end of the array
164	mIndex->mFrecencyArray.RemoveRecord(mOldRecord, mProofOfLock);
165	mIndex->mFrecencyArray.AppendRecord(entry->mRec, mProofOfLock);
166	}
167	} else if (entry->mRec->Get()->mFrecency != mOldFrecency) {
168	// Move the element at the end of the array
169	mIndex->mFrecencyArray.RemoveRecord(entry->mRec, mProofOfLock);
170	mIndex->mFrecencyArray.AppendRecord(entry->mRec, mProofOfLock);
171	}
172	} else {
173	// both entries were removed or not initialized, do nothing
174	}
175	}
176
177	// We cannot rely on nsTHashtable::GetEntry() in case we are removing entries
178	// while iterating. Destructor is called before the entry is removed. Caller
179	// must call one of following methods to skip lookup in the hashtable.
180	void DoNotSearchInIndex() { mDoNotSearchInIndex = true; }
181	void DoNotSearchInUpdates() { mDoNotSearchInUpdates = true; }
182
183	private:
184	const CacheIndexEntry* FindEntry() MOZ_REQUIRES(CacheIndex::sLock)__attribute__((exclusive_locks_required(CacheIndex::sLock))) {
185	const CacheIndexEntry* entry = nullptr;
186
187	switch (mIndex->mState) {
188	case CacheIndex::READING:
189	case CacheIndex::WRITING:
190	if (!mDoNotSearchInUpdates) {
191	entry = mIndex->mPendingUpdates.GetEntry(*mHash);
192	}
193	[[fallthrough]];
194	case CacheIndex::BUILDING:
195	case CacheIndex::UPDATING:
196	case CacheIndex::READY:
197	if (!entry && !mDoNotSearchInIndex) {
198	entry = mIndex->mIndex.GetEntry(*mHash);
199	}
200	break;
201	case CacheIndex::INITIAL:
202	case CacheIndex::SHUTDOWN:
203	default:
204	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 204); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 204 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
205	}
206
207	return entry;
208	}
209
210	const SHA1Sum::Hash* mHash;
211	RefPtr<CacheIndex> mIndex;
212	RefPtr<CacheIndexRecordWrapper> mOldRecord;
213	uint32_t mOldFrecency{0};
214	bool mDoNotSearchInIndex{false};
215	bool mDoNotSearchInUpdates{false};
216	const StaticMutexAutoLock& mProofOfLock;
217	};
218
219	class FileOpenHelper final : public CacheFileIOListener {
220	public:
221	NS_DECL_THREADSAFE_ISUPPORTSpublic: virtual nsresult QueryInterface(const nsIID& aIID , void** aInstancePtr) override; virtual MozExternalRefCountType AddRef(void) override; virtual MozExternalRefCountType Release (void) override; using HasThreadSafeRefCnt = std::true_type; protected : ::mozilla::ThreadSafeAutoRefCnt mRefCnt; nsAutoOwningThread _mOwningThread; public:
222
223	explicit FileOpenHelper(CacheIndex* aIndex)
224	: mIndex(aIndex), mCanceled(false) {}
225
226	void Cancel() {
227	CacheIndex::sLock.AssertCurrentThreadOwns();
228	mCanceled = true;
229	}
230
231	private:
232	virtual ~FileOpenHelper() = default;
233
234	NS_IMETHODvirtual nsresult OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) override;
235	NS_IMETHODvirtual nsresult OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
236	nsresult aResult) override {
237	MOZ_CRASH("FileOpenHelper::OnDataWritten should not be called!")do { do { } while (false); MOZ_ReportCrash("" "FileOpenHelper::OnDataWritten should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 237); AnnotateMozCrashReason("MOZ_CRASH(" "FileOpenHelper::OnDataWritten should not be called!" ")"); do { ((volatile int)__null) = 237; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
238	return NS_ERROR_UNEXPECTED;
239	}
240	NS_IMETHODvirtual nsresult OnDataRead(CacheFileHandle* aHandle, char* aBuf,
241	nsresult aResult) override {
242	MOZ_CRASH("FileOpenHelper::OnDataRead should not be called!")do { do { } while (false); MOZ_ReportCrash("" "FileOpenHelper::OnDataRead should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 242); AnnotateMozCrashReason("MOZ_CRASH(" "FileOpenHelper::OnDataRead should not be called!" ")"); do { ((volatile int)__null) = 242; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
243	return NS_ERROR_UNEXPECTED;
244	}
245	NS_IMETHODvirtual nsresult OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) override {
246	MOZ_CRASH("FileOpenHelper::OnFileDoomed should not be called!")do { do { } while (false); MOZ_ReportCrash("" "FileOpenHelper::OnFileDoomed should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 246); AnnotateMozCrashReason("MOZ_CRASH(" "FileOpenHelper::OnFileDoomed should not be called!" ")"); do { ((volatile int)__null) = 246; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
247	return NS_ERROR_UNEXPECTED;
248	}
249	NS_IMETHODvirtual nsresult OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) override {
250	MOZ_CRASH("FileOpenHelper::OnEOFSet should not be called!")do { do { } while (false); MOZ_ReportCrash("" "FileOpenHelper::OnEOFSet should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 250); AnnotateMozCrashReason("MOZ_CRASH(" "FileOpenHelper::OnEOFSet should not be called!" ")"); do { ((volatile int)__null) = 250; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
251	return NS_ERROR_UNEXPECTED;
252	}
253	NS_IMETHODvirtual nsresult OnFileRenamed(CacheFileHandle* aHandle,
254	nsresult aResult) override {
255	MOZ_CRASH("FileOpenHelper::OnFileRenamed should not be called!")do { do { } while (false); MOZ_ReportCrash("" "FileOpenHelper::OnFileRenamed should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 255); AnnotateMozCrashReason("MOZ_CRASH(" "FileOpenHelper::OnFileRenamed should not be called!" ")"); do { ((volatile int)__null) = 255; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
256	return NS_ERROR_UNEXPECTED;
257	}
258
259	RefPtr<CacheIndex> mIndex;
260	bool mCanceled;
261	};
262
263	NS_IMETHODIMPnsresult FileOpenHelper::OnFileOpened(CacheFileHandle* aHandle,
264	nsresult aResult) {
265	StaticMutexAutoLock lock(CacheIndex::sLock);
266
267	if (mCanceled) {
268	if (aHandle) {
269	CacheFileIOManager::DoomFile(aHandle, nullptr);
270	}
271
272	return NS_OK;
273	}
274
275	mIndex->OnFileOpenedInternal(this, aHandle, aResult, lock);
276
277	return NS_OK;
278	}
279
280	NS_IMPL_ISUPPORTS(FileOpenHelper, CacheFileIOListener)MozExternalRefCountType FileOpenHelper::AddRef(void) { static_assert (!std::is_destructible_v<FileOpenHelper>, "Reference-counted class " "FileOpenHelper" " should not have a public destructor. " "Make this class's destructor non-public" ); do { static_assert( mozilla::detail::AssertionConditionType <decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0" " (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 280); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0" ") (" "illegal refcnt" ")"); do { ((volatile int)__null) = 280; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); do { static_assert( mozilla::detail::AssertionConditionType <decltype("FileOpenHelper" != nullptr)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!("FileOpenHelper" != nullptr) )), 0))) { do { } while (false); MOZ_ReportAssertionFailure("\"FileOpenHelper\" != nullptr" " (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 280); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"FileOpenHelper\" != nullptr" ") (" "Must specify a name" ")"); do { ((volatile int)__null ) = 280; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread .AssertOwnership("FileOpenHelper" " not thread-safe"); nsrefcnt count = ++mRefCnt; NS_LogAddRef((this), (count), ("FileOpenHelper" ), (uint32_t)(sizeof(this))); return count; } MozExternalRefCountType FileOpenHelper::Release(void) { do { static_assert( mozilla:: detail::AssertionConditionType<decltype(int32_t(mRefCnt) > 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(int32_t(mRefCnt) > 0))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0" " (" "dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 280); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0" ") (" "dup release" ")"); do { ((volatile int)__null) = 280 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); do { static_assert( mozilla::detail::AssertionConditionType <decltype("FileOpenHelper" != nullptr)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!("FileOpenHelper" != nullptr) )), 0))) { do { } while (false); MOZ_ReportAssertionFailure("\"FileOpenHelper\" != nullptr" " (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 280); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"FileOpenHelper\" != nullptr" ") (" "Must specify a name" ")"); do { ((volatile int)__null ) = 280; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread .AssertOwnership("FileOpenHelper" " not thread-safe"); const char const nametmp = "FileOpenHelper"; nsrefcnt count = --mRefCnt ; NS_LogRelease((this), (count), (nametmp)); if (count == 0) { mRefCnt = 1; delete (this); return 0; } return count; } nsresult FileOpenHelper::QueryInterface(const nsIID& aIID, void** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak(NS_DEBUG_ASSERTION , "QueryInterface requires a non-NULL destination!", "aInstancePtr" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 280); MOZ_PretendNoReturn(); } } while (0); nsresult rv = NS_ERROR_FAILURE ; static_assert(1 > 0, "Need more arguments to NS_INTERFACE_TABLE" ); static const QITableEntry table[] = { {&mozilla::detail ::kImplementedIID<FileOpenHelper, CacheFileIOListener>, int32_t( reinterpret_cast<char>(static_cast<CacheFileIOListener >((FileOpenHelper)0x1000)) - reinterpret_cast<char> ((FileOpenHelper)0x1000))}, {&mozilla::detail::kImplementedIID <FileOpenHelper, nsISupports>, int32_t(reinterpret_cast <char>(static_cast<nsISupports>( static_cast< CacheFileIOListener>((FileOpenHelper)0x1000))) - reinterpret_cast <char>((FileOpenHelper)0x1000))}, { nullptr, 0 } } ; static_assert ((sizeof(table) / sizeof(table[0])) > 1, "need at least 1 interface" ); rv = NS_TableDrivenQI(static_cast<void>(this), aIID , aInstancePtr, table); return rv; };
281
282	StaticRefPtr<CacheIndex> CacheIndex::gInstance;
283	StaticMutex CacheIndex::sLock;
284
285	NS_IMPL_ADDREF(CacheIndex)MozExternalRefCountType CacheIndex::AddRef(void) { static_assert (!std::is_destructible_v<CacheIndex>, "Reference-counted class " "CacheIndex" " should not have a public destructor. " "Make this class's destructor non-public" ); do { static_assert( mozilla::detail::AssertionConditionType <decltype(int32_t(mRefCnt) >= 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) >= 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) >= 0" " (" "illegal refcnt" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 285); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) >= 0" ") (" "illegal refcnt" ")"); do { ((volatile int)__null) = 285; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); do { static_assert( mozilla::detail::AssertionConditionType <decltype("CacheIndex" != nullptr)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!("CacheIndex" != nullptr))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("\"CacheIndex\" != nullptr" " (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 285); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"CacheIndex\" != nullptr" ") (" "Must specify a name" ")"); do { ((volatile int)__null ) = 285; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread .AssertOwnership("CacheIndex" " not thread-safe"); nsrefcnt count = ++mRefCnt; NS_LogAddRef((this), (count), ("CacheIndex"), ( uint32_t)(sizeof(*this))); return count; }
286	NS_IMPL_RELEASE(CacheIndex)MozExternalRefCountType CacheIndex::Release(void) { do { static_assert ( mozilla::detail::AssertionConditionType<decltype(int32_t (mRefCnt) > 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(int32_t(mRefCnt) > 0))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("int32_t(mRefCnt) > 0" " (" "dup release" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 286); AnnotateMozCrashReason("MOZ_ASSERT" "(" "int32_t(mRefCnt) > 0" ") (" "dup release" ")"); do { ((volatile int)__null) = 286 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); do { static_assert( mozilla::detail::AssertionConditionType <decltype("CacheIndex" != nullptr)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!("CacheIndex" != nullptr))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("\"CacheIndex\" != nullptr" " (" "Must specify a name" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 286); AnnotateMozCrashReason("MOZ_ASSERT" "(" "\"CacheIndex\" != nullptr" ") (" "Must specify a name" ")"); do { ((volatile int)__null ) = 286; __attribute__((nomerge)) ::abort(); } while (false); } } while (false); if (!mRefCnt.isThreadSafe) _mOwningThread .AssertOwnership("CacheIndex" " not thread-safe"); const char * const nametmp = "CacheIndex"; nsrefcnt count = --mRefCnt; NS_LogRelease ((this), (count), (nametmp)); if (count == 0) { mRefCnt = 1; delete (this); return 0; } return count; }
287
288	NS_INTERFACE_MAP_BEGIN(CacheIndex)nsresult CacheIndex::QueryInterface(const nsIID& aIID, void ** aInstancePtr) { do { if (!(aInstancePtr)) { NS_DebugBreak( NS_DEBUG_ASSERTION, "QueryInterface requires a non-NULL destination!" , "aInstancePtr", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 288); MOZ_PretendNoReturn(); } } while (0); nsISupports* foundInterface ;
289	NS_INTERFACE_MAP_ENTRY(mozilla::net::CacheFileIOListener)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t <decltype(this)>, mozilla::net::CacheFileIOListener> )) foundInterface = static_cast<mozilla::net::CacheFileIOListener >(this); else
290	NS_INTERFACE_MAP_ENTRY(nsIRunnable)if (aIID.Equals(mozilla::detail::kImplementedIID<std::remove_reference_t <decltype(this)>, nsIRunnable>)) foundInterface = static_cast <nsIRunnable>(this); else
291	NS_INTERFACE_MAP_ENDfoundInterface = 0; nsresult status; if (!foundInterface) { do { static_assert( mozilla::detail::AssertionConditionType< decltype(!aIID.Equals((nsISupports::COMTypeInfo<nsISupports , void>::kIID)))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!aIID.Equals((nsISupports::COMTypeInfo <nsISupports, void>::kIID))))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 291); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!aIID.Equals((nsISupports::COMTypeInfo<nsISupports, void>::kIID))" ")"); do { ((volatile int)__null) = 291; __attribute__((nomerge )) ::abort(); } while (false); } } while (false); status = NS_NOINTERFACE ; } else { (foundInterface)->AddRef(); status = NS_OK; } * aInstancePtr = foundInterface; return status; }
292
293	CacheIndex::CacheIndex() {
294	sLock.AssertCurrentThreadOwns();
295	LOG(("CacheIndex::CacheIndex [this=%p]", this))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::CacheIndex [this=%p]" , this); } } while (0);
296	MOZ_ASSERT(!gInstance, "multiple CacheIndex instances!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(!gInstance)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!gInstance))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!gInstance" " (" "multiple CacheIndex instances!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 296); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!gInstance" ") (" "multiple CacheIndex instances!" ")"); do { ((volatile int )__null) = 296; __attribute__((nomerge)) ::abort(); } while ( false); } } while (false);
297	}
298
299	CacheIndex::~CacheIndex() {
300	sLock.AssertCurrentThreadOwns();
301	LOG(("CacheIndex::~CacheIndex [this=%p]", this))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::~CacheIndex [this=%p]" , this); } } while (0);
302
303	ReleaseBuffer();
304	}
305
306	// static
307	nsresult CacheIndex::Init(nsIFile* aCacheDirectory) {
308	LOG(("CacheIndex::Init()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Init()" ); } } while (0);
309
310	MOZ_ASSERT(NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(NS_IsMainThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(NS_IsMainThread()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("NS_IsMainThread()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 310); AnnotateMozCrashReason("MOZ_ASSERT" "(" "NS_IsMainThread()" ")"); do { ((volatile int)__null) = 310; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
311
312	StaticMutexAutoLock lock(sLock);
313
314	if (gInstance) {
315	return NS_ERROR_ALREADY_INITIALIZED;
316	}
317
318	RefPtr<CacheIndex> idx = new CacheIndex();
319
320	nsresult rv = idx->InitInternal(aCacheDirectory, lock);
321	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 321); return rv; } } while (false);
322
323	gInstance = std::move(idx);
324	return NS_OK;
325	}
326
327	nsresult CacheIndex::InitInternal(nsIFile* aCacheDirectory,
328	const StaticMutexAutoLock& aProofOfLock) {
329	nsresult rv;
330	sLock.AssertCurrentThreadOwns();
331
332	rv = aCacheDirectory->Clone(getter_AddRefs(mCacheDirectory));
333	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 333); return rv; } } while (false);
334
335	mStartTime = TimeStamp::NowLoRes();
336
337	ReadIndexFromDisk(aProofOfLock);
338
339	return NS_OK;
340	}
341
342	// static
343	nsresult CacheIndex::PreShutdown() {
344	MOZ_ASSERT(NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(NS_IsMainThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(NS_IsMainThread()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("NS_IsMainThread()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 344); AnnotateMozCrashReason("MOZ_ASSERT" "(" "NS_IsMainThread()" ")"); do { ((volatile int)__null) = 344; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
345
346	StaticMutexAutoLock lock(sLock);
347
348	LOG(("CacheIndex::PreShutdown() [gInstance=%p]", gInstance.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() [gInstance=%p]" , gInstance.get()); } } while (0);
349
350	nsresult rv;
351	RefPtr<CacheIndex> index = gInstance;
352
353	if (!index) {
354	return NS_ERROR_NOT_INITIALIZED;
355	}
356
357	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", index->mState, index->mIndexOnDiskIsValid , index->mDontMarkIndexClean); } } while (0)
358	("CacheIndex::PreShutdown() - [state=%d, indexOnDiskIsValid=%d, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", index->mState, index->mIndexOnDiskIsValid , index->mDontMarkIndexClean); } } while (0)
359	"dontMarkIndexClean=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", index->mState, index->mIndexOnDiskIsValid , index->mDontMarkIndexClean); } } while (0)
360	index->mState, index->mIndexOnDiskIsValid, index->mDontMarkIndexClean))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", index->mState, index->mIndexOnDiskIsValid , index->mDontMarkIndexClean); } } while (0);
361
362	LOG(("CacheIndex::PreShutdown() - Closing iterators."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Closing iterators." ); } } while (0);
363	for (uint32_t i = 0; i < index->mIterators.Length();) {
364	rv = index->mIterators[i]->CloseInternal(NS_ERROR_FAILURE);
365	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
366	// CacheIndexIterator::CloseInternal() removes itself from mIteratos iff
367	// it returns success.
368	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
369	("CacheIndex::PreShutdown() - Failed to remove iterator %p. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
370	"[rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
371	index->mIterators[i], static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0);
372	i++;
373	}
374	}
375
376	index->mShuttingDown = true;
377
378	if (index->mState == READY) {
379	return NS_OK; // nothing to do
380	}
381
382	nsCOMPtr<nsIRunnable> event;
383	event = NewRunnableMethod("net::CacheIndex::PreShutdownInternal", index,
384	&CacheIndex::PreShutdownInternal);
385
386	nsCOMPtr<nsIEventTarget> ioTarget = CacheFileIOManager::IOTarget();
387	MOZ_ASSERT(ioTarget)do { static_assert( mozilla::detail::AssertionConditionType< decltype(ioTarget)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(ioTarget))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("ioTarget", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 387); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ioTarget" ")" ); do { ((volatile int)__null) = 387; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
388
389	// PreShutdownInternal() will be executed before any queued event on INDEX
390	// level. That's OK since we don't want to wait for any operation in progess.
391	rv = ioTarget->Dispatch(event, nsIEventTarget::DISPATCH_NORMAL);
392	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
393	NS_WARNING("CacheIndex::PreShutdown() - Can't dispatch event")NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::PreShutdown() - Can't dispatch event" , nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 393);
394	LOG(("CacheIndex::PreShutdown() - Can't dispatch event"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdown() - Can't dispatch event" ); } } while (0);
395	return rv;
396	}
397
398	return NS_OK;
399	}
400
401	void CacheIndex::PreShutdownInternal() {
402	StaticMutexAutoLock lock(sLock);
403
404	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", mState, mIndexOnDiskIsValid, mDontMarkIndexClean ); } } while (0)
405	("CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", mState, mIndexOnDiskIsValid, mDontMarkIndexClean ); } } while (0)
406	"dontMarkIndexClean=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", mState, mIndexOnDiskIsValid, mDontMarkIndexClean ); } } while (0)
407	mState, mIndexOnDiskIsValid, mDontMarkIndexClean))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::PreShutdownInternal() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d]", mState, mIndexOnDiskIsValid, mDontMarkIndexClean ); } } while (0);
408
409	MOZ_ASSERT(mShuttingDown)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mShuttingDown)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mShuttingDown))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mShuttingDown", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 409); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mShuttingDown" ")"); do { ((volatile int)__null) = 409; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
410
411	if (mUpdateTimer) {
412	mUpdateTimer->Cancel();
413	mUpdateTimer = nullptr;
414	}
415
416	switch (mState) {
417	case WRITING:
418	FinishWrite(false, lock);
419	break;
420	case READY:
421	// nothing to do, write the journal in Shutdown()
422	break;
423	case READING:
424	FinishRead(false, lock);
425	break;
426	case BUILDING:
427	case UPDATING:
428	FinishUpdate(false, lock);
429	break;
430	default:
431	MOZ_ASSERT(false, "Implement me!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Implement me!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 431); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Implement me!" ")"); do { ((volatile int)__null) = 431; __attribute__ ((nomerge)) ::abort(); } while (false); } } while (false);
432	}
433
434	// We should end up in READY state
435	MOZ_ASSERT(mState == READY)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == READY)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == READY))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == READY" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 435); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == READY" ")"); do { ((volatile int)__null) = 435; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
436	}
437
438	// static
439	nsresult CacheIndex::Shutdown() {
440	MOZ_ASSERT(NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(NS_IsMainThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(NS_IsMainThread()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("NS_IsMainThread()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 440); AnnotateMozCrashReason("MOZ_ASSERT" "(" "NS_IsMainThread()" ")"); do { ((volatile int)__null) = 440; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
441
442	StaticMutexAutoLock lock(sLock);
443
444	LOG(("CacheIndex::Shutdown() [gInstance=%p]", gInstance.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() [gInstance=%p]" , gInstance.get()); } } while (0);
445
446	RefPtr<CacheIndex> index = gInstance.forget();
447
448	if (!index) {
449	return NS_ERROR_NOT_INITIALIZED;
450	}
451
452	bool sanitize = CacheObserver::ClearCacheOnShutdown();
453
454	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d, sanitize=%d]", index->mState, index ->mIndexOnDiskIsValid, index->mDontMarkIndexClean, sanitize ); } } while (0)
455	("CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d, sanitize=%d]", index->mState, index ->mIndexOnDiskIsValid, index->mDontMarkIndexClean, sanitize ); } } while (0)
456	"dontMarkIndexClean=%d, sanitize=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d, sanitize=%d]", index->mState, index ->mIndexOnDiskIsValid, index->mDontMarkIndexClean, sanitize ); } } while (0)
457	index->mState, index->mIndexOnDiskIsValid, index->mDontMarkIndexClean,do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d, sanitize=%d]", index->mState, index ->mIndexOnDiskIsValid, index->mDontMarkIndexClean, sanitize ); } } while (0)
458	sanitize))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - [state=%d, indexOnDiskIsValid=%d, " "dontMarkIndexClean=%d, sanitize=%d]", index->mState, index ->mIndexOnDiskIsValid, index->mDontMarkIndexClean, sanitize ); } } while (0);
459
460	MOZ_ASSERT(index->mShuttingDown)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mShuttingDown)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(index->mShuttingDown))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("index->mShuttingDown" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 460); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mShuttingDown" ")"); do { ((volatile int)__null) = 460; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
461
462	EState oldState = index->mState;
463	index->ChangeState(SHUTDOWN, lock);
464
465	if (oldState != READY) {
466	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - Unexpected state. Did posting of " "PreShutdownInternal() fail?"); } } while (0)
467	("CacheIndex::Shutdown() - Unexpected state. Did posting of "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - Unexpected state. Did posting of " "PreShutdownInternal() fail?"); } } while (0)
468	"PreShutdownInternal() fail?"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Shutdown() - Unexpected state. Did posting of " "PreShutdownInternal() fail?"); } } while (0);
469	}
470
471	switch (oldState) {
472	case WRITING:
473	index->FinishWrite(false, lock);
474	[[fallthrough]];
475	case READY:
476	if (index->mIndexOnDiskIsValid && !index->mDontMarkIndexClean) {
477	if (!sanitize && NS_FAILED(index->WriteLogToDisk())((bool)(__builtin_expect(!!(NS_FAILED_impl(index->WriteLogToDisk ())), 0)))) {
478	index->RemoveJournalAndTempFile();
479	}
480	} else {
481	index->RemoveJournalAndTempFile();
482	}
483	break;
484	case READING:
485	index->FinishRead(false, lock);
486	break;
487	case BUILDING:
488	case UPDATING:
489	index->FinishUpdate(false, lock);
490	break;
491	default:
492	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 492); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 492 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
493	}
494
495	if (sanitize) {
496	index->RemoveAllIndexFiles();
497	}
498
499	return NS_OK;
500	}
501
502	// static
503	nsresult CacheIndex::AddEntry(const SHA1Sum::Hash* aHash) {
504	LOG(("CacheIndex::AddEntry() [hash=%08x%08x%08x%08x%08x]", LOGSHA1(aHash)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0 ]), PR_htonl((reinterpret_cast<const uint32_t>(aHash)) [1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[3]), PR_htonl((reinterpret_cast<const uint32_t*>(aHash ))[4])); } } while (0);
505
506	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 506); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 506; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
507
508	StaticMutexAutoLock lock(sLock);
509
510	RefPtr<CacheIndex> index = gInstance;
511
512	if (!index) {
513	return NS_ERROR_NOT_INITIALIZED;
514	}
515
516	if (!index->IsIndexUsable()) {
517	return NS_ERROR_NOT_AVAILABLE;
518	}
519
520	// Getters in CacheIndexStats assert when mStateLogged is true since the
521	// information is incomplete between calls to BeforeChange() and AfterChange()
522	// (i.e. while CacheIndexEntryAutoManage exists). We need to check whether
523	// non-fresh entries exists outside the scope of CacheIndexEntryAutoManage.
524	bool updateIfNonFreshEntriesExist = false;
525
526	{
527	CacheIndexEntryAutoManage entryMng(aHash, index, lock);
528
529	CacheIndexEntry* entry = index->mIndex.GetEntry(*aHash);
530	bool entryRemoved = entry && entry->IsRemoved();
531	CacheIndexEntryUpdate* updated = nullptr;
532
533	if (index->mState == READY \|\| index->mState == UPDATING \|\|
534	index->mState == BUILDING) {
535	MOZ_ASSERT(index->mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mPendingUpdates.Count() == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(index->mPendingUpdates.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mPendingUpdates.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 535); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 535; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
536
537	if (entry && !entryRemoved) {
538	// Found entry in index that shouldn't exist.
539
540	if (entry->IsFresh()) {
541	// Someone removed the file on disk while FF is running. Update
542	// process can fix only non-fresh entries (i.e. entries that were not
543	// added within this session). Start update only if we have such
544	// entries.
545	//
546	// TODO: This should be very rare problem. If it turns out not to be
547	// true, change the update process so that it also iterates all
548	// initialized non-empty entries and checks whether the file exists.
549
550	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0)
551	("CacheIndex::AddEntry() - Cache file was removed outside FF "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0)
552	"process!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0);
553
554	updateIfNonFreshEntriesExist = true;
555	} else if (index->mState == READY) {
556	// Index is outdated, update it.
557	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0)
558	("CacheIndex::AddEntry() - Found entry that shouldn't exist, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0)
559	"update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0);
560	index->mIndexNeedsUpdate = true;
561	} else {
562	// We cannot be here when building index since all entries are fresh
563	// during building.
564	MOZ_ASSERT(index->mState == UPDATING)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mState == UPDATING)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(index->mState == UPDATING ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "index->mState == UPDATING", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 564); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mState == UPDATING" ")"); do { ((volatile int)__null) = 564; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
565	}
566	}
567
568	if (!entry) {
569	entry = index->mIndex.PutEntry(*aHash);
570	}
571	} else { // WRITING, READING
572	updated = index->mPendingUpdates.GetEntry(*aHash);
573	bool updatedRemoved = updated && updated->IsRemoved();
574
575	if ((updated && !updatedRemoved) \|\|
576	(!updated && entry && !entryRemoved && entry->IsFresh())) {
577	// Fresh entry found, so the file was removed outside FF
578	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0)
579	("CacheIndex::AddEntry() - Cache file was removed outside FF "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0)
580	"process!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Cache file was removed outside FF " "process!"); } } while (0);
581
582	updateIfNonFreshEntriesExist = true;
583	} else if (!updated && entry && !entryRemoved) {
584	if (index->mState == WRITING) {
585	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0)
586	("CacheIndex::AddEntry() - Found entry that shouldn't exist, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0)
587	"update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AddEntry() - Found entry that shouldn't exist, " "update is needed"); } } while (0);
588	index->mIndexNeedsUpdate = true;
589	}
590	// Ignore if state is READING since the index information is partial
591	}
592
593	updated = index->mPendingUpdates.PutEntry(*aHash);
594	}
595
596	if (updated) {
597	updated->InitNew();
598	updated->MarkDirty();
599	updated->MarkFresh();
600	} else {
601	entry->InitNew();
602	entry->MarkDirty();
603	entry->MarkFresh();
604	}
605	}
606
607	if (updateIfNonFreshEntriesExist &&
608	index->mIndexStats.Count() != index->mIndexStats.Fresh()) {
609	index->mIndexNeedsUpdate = true;
610	}
611
612	index->StartUpdatingIndexIfNeeded(lock);
613	index->WriteIndexToDiskIfNeeded(lock);
614
615	return NS_OK;
616	}
617
618	// static
619	nsresult CacheIndex::EnsureEntryExists(const SHA1Sum::Hash* aHash) {
620	LOG(("CacheIndex::EnsureEntryExists() [hash=%08x%08x%08x%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0 ]), PR_htonl((reinterpret_cast<const uint32_t>(aHash)) [1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[3]), PR_htonl((reinterpret_cast<const uint32_t*>(aHash ))[4])); } } while (0)
621	LOGSHA1(aHash)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0 ]), PR_htonl((reinterpret_cast<const uint32_t>(aHash)) [1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[3]), PR_htonl((reinterpret_cast<const uint32_t*>(aHash ))[4])); } } while (0);
622
623	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 623); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 623; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
624
625	StaticMutexAutoLock lock(sLock);
626
627	RefPtr<CacheIndex> index = gInstance;
628
629	if (!index) {
630	return NS_ERROR_NOT_INITIALIZED;
631	}
632
633	if (!index->IsIndexUsable()) {
634	return NS_ERROR_NOT_AVAILABLE;
635	}
636
637	{
638	CacheIndexEntryAutoManage entryMng(aHash, index, lock);
639
640	CacheIndexEntry* entry = index->mIndex.GetEntry(*aHash);
641	bool entryRemoved = entry && entry->IsRemoved();
642
643	if (index->mState == READY \|\| index->mState == UPDATING \|\|
644	index->mState == BUILDING) {
645	MOZ_ASSERT(index->mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mPendingUpdates.Count() == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(index->mPendingUpdates.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mPendingUpdates.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 645); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 645; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
646
647	if (!entry \|\| entryRemoved) {
648	if (entryRemoved && entry->IsFresh()) {
649	// This could happen only if somebody copies files to the entries
650	// directory while FF is running.
651	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0)
652	("CacheIndex::EnsureEntryExists() - Cache file was added outside "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0)
653	"FF process! Update is needed."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0);
654	index->mIndexNeedsUpdate = true;
655	} else if (index->mState == READY \|\|
656	(entryRemoved && !entry->IsFresh())) {
657	// Removed non-fresh entries can be present as a result of
658	// MergeJournal()
659	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0)
660	("CacheIndex::EnsureEntryExists() - Didn't find entry that should"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0)
661	" exist, update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0);
662	index->mIndexNeedsUpdate = true;
663	}
664
665	if (!entry) {
666	entry = index->mIndex.PutEntry(*aHash);
667	}
668	entry->InitNew();
669	entry->MarkDirty();
670	}
671	entry->MarkFresh();
672	} else { // WRITING, READING
673	CacheIndexEntryUpdate* updated = index->mPendingUpdates.GetEntry(*aHash);
674	bool updatedRemoved = updated && updated->IsRemoved();
675
676	if (updatedRemoved \|\| (!updated && entryRemoved && entry->IsFresh())) {
677	// Fresh information about missing entry found. This could happen only
678	// if somebody copies files to the entries directory while FF is
679	// running.
680	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0)
681	("CacheIndex::EnsureEntryExists() - Cache file was added outside "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0)
682	"FF process! Update is needed."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Cache file was added outside " "FF process! Update is needed."); } } while (0);
683	index->mIndexNeedsUpdate = true;
684	} else if (!updated && (!entry \|\| entryRemoved)) {
685	if (index->mState == WRITING) {
686	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0)
687	("CacheIndex::EnsureEntryExists() - Didn't find entry that should"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0)
688	" exist, update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::EnsureEntryExists() - Didn't find entry that should" " exist, update is needed"); } } while (0);
689	index->mIndexNeedsUpdate = true;
690	}
691	// Ignore if state is READING since the index information is partial
692	}
693
694	// We don't need entryRemoved and updatedRemoved info anymore
695	if (entryRemoved) entry = nullptr;
696	if (updatedRemoved) updated = nullptr;
697
698	if (updated) {
699	updated->MarkFresh();
700	} else {
701	if (!entry) {
702	// Create a new entry
703	updated = index->mPendingUpdates.PutEntry(*aHash);
704	updated->InitNew();
705	updated->MarkFresh();
706	updated->MarkDirty();
707	} else {
708	if (!entry->IsFresh()) {
709	// To mark the entry fresh we must make a copy of index entry
710	// since the index is read-only.
711	updated = index->mPendingUpdates.PutEntry(*aHash);
712	updated = entry;
713	updated->MarkFresh();
714	}
715	}
716	}
717	}
718	}
719
720	index->StartUpdatingIndexIfNeeded(lock);
721	index->WriteIndexToDiskIfNeeded(lock);
722
723	return NS_OK;
724	}
725
726	// static
727	nsresult CacheIndex::InitEntry(const SHA1Sum::Hash* aHash,
728	OriginAttrsHash aOriginAttrsHash,
729	bool aAnonymous, bool aPinned) {
730	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() [hash=%08x%08x%08x%08x%08x, " "originAttrsHash=%" "l" "x" ", anonymous=%d, pinned=%d]", PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl ((reinterpret_cast<const uint32_t*>(aHash))[4]), aOriginAttrsHash , aAnonymous, aPinned); } } while (0)
731	("CacheIndex::InitEntry() [hash=%08x%08x%08x%08x%08x, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() [hash=%08x%08x%08x%08x%08x, " "originAttrsHash=%" "l" "x" ", anonymous=%d, pinned=%d]", PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl ((reinterpret_cast<const uint32_t*>(aHash))[4]), aOriginAttrsHash , aAnonymous, aPinned); } } while (0)
732	"originAttrsHash=%" PRIx64 ", anonymous=%d, pinned=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() [hash=%08x%08x%08x%08x%08x, " "originAttrsHash=%" "l" "x" ", anonymous=%d, pinned=%d]", PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl ((reinterpret_cast<const uint32_t*>(aHash))[4]), aOriginAttrsHash , aAnonymous, aPinned); } } while (0)
733	LOGSHA1(aHash), aOriginAttrsHash, aAnonymous, aPinned))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() [hash=%08x%08x%08x%08x%08x, " "originAttrsHash=%" "l" "x" ", anonymous=%d, pinned=%d]", PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl ((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl ((reinterpret_cast<const uint32_t*>(aHash))[4]), aOriginAttrsHash , aAnonymous, aPinned); } } while (0);
734
735	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 735); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 735; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
736
737	StaticMutexAutoLock lock(sLock);
738
739	RefPtr<CacheIndex> index = gInstance;
740
741	if (!index) {
742	return NS_ERROR_NOT_INITIALIZED;
743	}
744
745	if (!index->IsIndexUsable()) {
746	return NS_ERROR_NOT_AVAILABLE;
747	}
748
749	{
750	CacheIndexEntryAutoManage entryMng(aHash, index, lock);
751
752	CacheIndexEntry* entry = index->mIndex.GetEntry(*aHash);
753	CacheIndexEntryUpdate* updated = nullptr;
754	bool reinitEntry = false;
755
756	if (entry && entry->IsRemoved()) {
757	entry = nullptr;
758	}
759
760	if (index->mState == READY \|\| index->mState == UPDATING \|\|
761	index->mState == BUILDING) {
762	MOZ_ASSERT(index->mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mPendingUpdates.Count() == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(index->mPendingUpdates.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mPendingUpdates.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 762); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 762; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
763	MOZ_ASSERT(entry)do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(entry))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("entry", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 763); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry" ")"); do { ((volatile int)__null) = 763; __attribute__((nomerge) ) ::abort(); } while (false); } } while (false);
764	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 764); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 764; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
765
766	if (!entry) {
767	LOG(("CacheIndex::InitEntry() - Entry was not found in mIndex!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() - Entry was not found in mIndex!" ); } } while (0);
768	NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::InitEntry() - Entry was not found in mIndex!" ), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 769)
769	("CacheIndex::InitEntry() - Entry was not found in mIndex!"))NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::InitEntry() - Entry was not found in mIndex!" ), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 769);
770	return NS_ERROR_UNEXPECTED;
771	}
772
773	if (IsCollision(entry, aOriginAttrsHash, aAnonymous)) {
774	index->mIndexNeedsUpdate =
775	true; // TODO Does this really help in case of collision?
776	reinitEntry = true;
777	} else {
778	if (entry->IsInitialized()) {
779	return NS_OK;
780	}
781	}
782	} else {
783	updated = index->mPendingUpdates.GetEntry(*aHash);
784	DebugOnly<bool> removed = updated && updated->IsRemoved();
785
786	MOZ_ASSERT(updated \|\| !removed)do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated \|\| !removed)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated \|\| !removed))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("updated \|\| !removed" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 786); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated \|\| !removed" ")"); do { ((volatile int)__null) = 786; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
787	MOZ_ASSERT(updated \|\| entry)do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated \|\| entry)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated \|\| entry))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("updated \|\| entry" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 787); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated \|\| entry" ")"); do { ((volatile int)__null) = 787; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
788
789	if (!updated && !entry) {
790	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() - Entry was found neither in mIndex nor " "in mPendingUpdates!"); } } while (0)
791	("CacheIndex::InitEntry() - Entry was found neither in mIndex nor "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() - Entry was found neither in mIndex nor " "in mPendingUpdates!"); } } while (0)
792	"in mPendingUpdates!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::InitEntry() - Entry was found neither in mIndex nor " "in mPendingUpdates!"); } } while (0);
793	NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::InitEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 795)
794	("CacheIndex::InitEntry() - Entry was found neither in "NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::InitEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 795)
795	"mIndex nor in mPendingUpdates!"))NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::InitEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 795);
796	return NS_ERROR_UNEXPECTED;
797	}
798
799	if (updated) {
800	MOZ_ASSERT(updated->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated->IsFresh()))), 0) )) { do { } while (false); MOZ_ReportAssertionFailure("updated->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 800); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated->IsFresh()" ")"); do { ((volatile int)__null) = 800; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
801
802	if (IsCollision(updated, aOriginAttrsHash, aAnonymous)) {
803	index->mIndexNeedsUpdate = true;
804	reinitEntry = true;
805	} else {
806	if (updated->IsInitialized()) {
807	return NS_OK;
808	}
809	}
810	} else {
811	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 811); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 811; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
812
813	if (IsCollision(entry, aOriginAttrsHash, aAnonymous)) {
814	index->mIndexNeedsUpdate = true;
815	reinitEntry = true;
816	} else {
817	if (entry->IsInitialized()) {
818	return NS_OK;
819	}
820	}
821
822	// make a copy of a read-only entry
823	updated = index->mPendingUpdates.PutEntry(*aHash);
824	updated = entry;
825	}
826	}
827
828	if (reinitEntry) {
829	// There is a collision and we are going to rewrite this entry. Initialize
830	// it as a new entry.
831	if (updated) {
832	updated->InitNew();
833	updated->MarkFresh();
834	} else {
835	entry->InitNew();
836	entry->MarkFresh();
837	}
838	}
839
840	if (updated) {
841	updated->Init(aOriginAttrsHash, aAnonymous, aPinned);
842	updated->MarkDirty();
843	} else {
844	entry->Init(aOriginAttrsHash, aAnonymous, aPinned);
845	entry->MarkDirty();
846	}
847	}
848
849	index->StartUpdatingIndexIfNeeded(lock);
850	index->WriteIndexToDiskIfNeeded(lock);
851
852	return NS_OK;
853	}
854
855	// static
856	nsresult CacheIndex::RemoveEntry(const SHA1Sum::Hash* aHash) {
857	LOG(("CacheIndex::RemoveEntry() [hash=%08x%08x%08x%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0 ]), PR_htonl((reinterpret_cast<const uint32_t>(aHash)) [1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[3]), PR_htonl((reinterpret_cast<const uint32_t*>(aHash ))[4])); } } while (0)
858	LOGSHA1(aHash)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0 ]), PR_htonl((reinterpret_cast<const uint32_t>(aHash)) [1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash ))[3]), PR_htonl((reinterpret_cast<const uint32_t*>(aHash ))[4])); } } while (0);
859
860	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 860); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 860; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
861
862	StaticMutexAutoLock lock(sLock);
863
864	RefPtr<CacheIndex> index = gInstance;
865
866	if (!index) {
867	return NS_ERROR_NOT_INITIALIZED;
868	}
869
870	if (!index->IsIndexUsable()) {
871	return NS_ERROR_NOT_AVAILABLE;
872	}
873
874	{
875	CacheIndexEntryAutoManage entryMng(aHash, index, lock);
876
877	CacheIndexEntry* entry = index->mIndex.GetEntry(*aHash);
878	bool entryRemoved = entry && entry->IsRemoved();
879
880	if (index->mState == READY \|\| index->mState == UPDATING \|\|
881	index->mState == BUILDING) {
882	MOZ_ASSERT(index->mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mPendingUpdates.Count() == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(index->mPendingUpdates.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mPendingUpdates.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 882); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 882; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
883
884	if (!entry \|\| entryRemoved) {
885	if (entryRemoved && entry->IsFresh()) {
886	// This could happen only if somebody copies files to the entries
887	// directory while FF is running.
888	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0)
889	("CacheIndex::RemoveEntry() - Cache file was added outside FF "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0)
890	"process! Update is needed."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0);
891	index->mIndexNeedsUpdate = true;
892	} else if (index->mState == READY \|\|
893	(entryRemoved && !entry->IsFresh())) {
894	// Removed non-fresh entries can be present as a result of
895	// MergeJournal()
896	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0)
897	("CacheIndex::RemoveEntry() - Didn't find entry that should exist"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0)
898	", update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0);
899	index->mIndexNeedsUpdate = true;
900	}
901	} else {
902	if (entry) {
903	if (!entry->IsDirty() && entry->IsFileEmpty()) {
904	index->mIndex.RemoveEntry(entry);
905	entry = nullptr;
906	} else {
907	entry->MarkRemoved();
908	entry->MarkDirty();
909	entry->MarkFresh();
910	}
911	}
912	}
913	} else { // WRITING, READING
914	CacheIndexEntryUpdate* updated = index->mPendingUpdates.GetEntry(*aHash);
915	bool updatedRemoved = updated && updated->IsRemoved();
916
917	if (updatedRemoved \|\| (!updated && entryRemoved && entry->IsFresh())) {
918	// Fresh information about missing entry found. This could happen only
919	// if somebody copies files to the entries directory while FF is
920	// running.
921	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0)
922	("CacheIndex::RemoveEntry() - Cache file was added outside FF "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0)
923	"process! Update is needed."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Cache file was added outside FF " "process! Update is needed."); } } while (0);
924	index->mIndexNeedsUpdate = true;
925	} else if (!updated && (!entry \|\| entryRemoved)) {
926	if (index->mState == WRITING) {
927	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0)
928	("CacheIndex::RemoveEntry() - Didn't find entry that should exist"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0)
929	", update is needed"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveEntry() - Didn't find entry that should exist" ", update is needed"); } } while (0);
930	index->mIndexNeedsUpdate = true;
931	}
932	// Ignore if state is READING since the index information is partial
933	}
934
935	if (!updated) {
936	updated = index->mPendingUpdates.PutEntry(*aHash);
937	updated->InitNew();
938	}
939
940	updated->MarkRemoved();
941	updated->MarkDirty();
942	updated->MarkFresh();
943	}
944	}
945	index->StartUpdatingIndexIfNeeded(lock);
946	index->WriteIndexToDiskIfNeeded(lock);
947
948	return NS_OK;
949	}
950
951	// static
952	nsresult CacheIndex::UpdateEntry(const SHA1Sum::Hash* aHash,
953	const uint32_t* aFrecency,
954	const bool* aHasAltData,
955	const uint16_t* aOnStartTime,
956	const uint16_t* aOnStopTime,
957	const uint8_t* aContentType,
958	const uint32_t* aSize) {
959	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
960	("CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
961	"frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
962	"contentType=%s, size=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
963	LOGSHA1(aHash), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "",do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
964	aHasAltData ? (aHasAltData ? "true" : "false") : "",do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
965	aOnStartTime ? nsPrintfCString("%u", aOnStartTime).get() : "",do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
966	aOnStopTime ? nsPrintfCString("%u", aOnStopTime).get() : "",do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
967	aContentType ? nsPrintfCString("%u", aContentType).get() : "",do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0)
968	aSize ? nsPrintfCString("%u", aSize).get() : ""))do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() [hash=%08x%08x%08x%08x%08x, " "frecency=%s, hasAltData=%s, onStartTime=%s, onStopTime=%s, " "contentType=%s, size=%s]", PR_htonl((reinterpret_cast<const uint32_t>(aHash))[0]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[1]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[2]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[3]), PR_htonl((reinterpret_cast<const uint32_t>(aHash))[4]), aFrecency ? nsPrintfCString("%u", aFrecency).get() : "", aHasAltData ? (aHasAltData ? "true" : "false") : "", aOnStartTime ? nsPrintfCString("%u", aOnStartTime ).get() : "", aOnStopTime ? nsPrintfCString("%u", aOnStopTime ).get() : "", aContentType ? nsPrintfCString("%u", aContentType ).get() : "", aSize ? nsPrintfCString("%u", *aSize).get() : "" ); } } while (0);
969
970	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 970); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 970; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
971
972	StaticMutexAutoLock lock(sLock);
973
974	RefPtr<CacheIndex> index = gInstance;
975
976	if (!index) {
977	return NS_ERROR_NOT_INITIALIZED;
978	}
979
980	if (!index->IsIndexUsable()) {
981	return NS_ERROR_NOT_AVAILABLE;
982	}
983
984	{
985	CacheIndexEntryAutoManage entryMng(aHash, index, lock);
986
987	CacheIndexEntry* entry = index->mIndex.GetEntry(*aHash);
988
989	if (entry && entry->IsRemoved()) {
990	entry = nullptr;
991	}
992
993	if (index->mState == READY \|\| index->mState == UPDATING \|\|
994	index->mState == BUILDING) {
995	MOZ_ASSERT(index->mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mPendingUpdates.Count() == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(index->mPendingUpdates.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mPendingUpdates.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 995); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 995; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
996	MOZ_ASSERT(entry)do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(entry))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("entry", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 996); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry" ")"); do { ((volatile int)__null) = 996; __attribute__((nomerge) ) ::abort(); } while (false); } } while (false);
997
998	if (!entry) {
999	LOG(("CacheIndex::UpdateEntry() - Entry was not found in mIndex!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() - Entry was not found in mIndex!" ); } } while (0);
1000	NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::UpdateEntry() - Entry was not found in mIndex!" ), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1001)
1001	("CacheIndex::UpdateEntry() - Entry was not found in mIndex!"))NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::UpdateEntry() - Entry was not found in mIndex!" ), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1001);
1002	return NS_ERROR_UNEXPECTED;
1003	}
1004
1005	if (!HasEntryChanged(entry, aFrecency, aHasAltData, aOnStartTime,
1006	aOnStopTime, aContentType, aSize)) {
1007	return NS_OK;
1008	}
1009
1010	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1010); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 1010; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1011	MOZ_ASSERT(entry->IsInitialized())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsInitialized())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsInitialized()))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsInitialized()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1011); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsInitialized()" ")"); do { ((volatile int)__null) = 1011; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1012	entry->MarkDirty();
1013
1014	if (aFrecency) {
1015	entry->SetFrecency(*aFrecency);
1016	}
1017
1018	if (aHasAltData) {
1019	entry->SetHasAltData(*aHasAltData);
1020	}
1021
1022	if (aOnStartTime) {
1023	entry->SetOnStartTime(*aOnStartTime);
1024	}
1025
1026	if (aOnStopTime) {
1027	entry->SetOnStopTime(*aOnStopTime);
1028	}
1029
1030	if (aContentType) {
1031	entry->SetContentType(*aContentType);
1032	}
1033
1034	if (aSize) {
1035	entry->SetFileSize(*aSize);
1036	}
1037	} else {
1038	CacheIndexEntryUpdate* updated = index->mPendingUpdates.GetEntry(*aHash);
1039	DebugOnly<bool> removed = updated && updated->IsRemoved();
1040
1041	MOZ_ASSERT(updated \|\| !removed)do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated \|\| !removed)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated \|\| !removed))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("updated \|\| !removed" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1041); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated \|\| !removed" ")"); do { ((volatile int)__null) = 1041; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1042	MOZ_ASSERT(updated \|\| entry)do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated \|\| entry)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated \|\| entry))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("updated \|\| entry" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1042); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated \|\| entry" ")"); do { ((volatile int)__null) = 1042; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1043
1044	if (!updated) {
1045	if (!entry) {
1046	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() - Entry was found neither in mIndex " "nor in mPendingUpdates!"); } } while (0)
1047	("CacheIndex::UpdateEntry() - Entry was found neither in mIndex "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() - Entry was found neither in mIndex " "nor in mPendingUpdates!"); } } while (0)
1048	"nor in mPendingUpdates!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateEntry() - Entry was found neither in mIndex " "nor in mPendingUpdates!"); } } while (0);
1049	NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::UpdateEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1051)
1050	("CacheIndex::UpdateEntry() - Entry was found neither in "NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::UpdateEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1051)
1051	"mIndex nor in mPendingUpdates!"))NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::UpdateEntry() - Entry was found neither in " "mIndex nor in mPendingUpdates!"), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1051);
1052	return NS_ERROR_UNEXPECTED;
1053	}
1054
1055	// make a copy of a read-only entry
1056	updated = index->mPendingUpdates.PutEntry(*aHash);
1057	updated = entry;
1058	}
1059
1060	MOZ_ASSERT(updated->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated->IsFresh()))), 0) )) { do { } while (false); MOZ_ReportAssertionFailure("updated->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1060); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated->IsFresh()" ")"); do { ((volatile int)__null) = 1060; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1061	MOZ_ASSERT(updated->IsInitialized())do { static_assert( mozilla::detail::AssertionConditionType< decltype(updated->IsInitialized())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(updated->IsInitialized()) )), 0))) { do { } while (false); MOZ_ReportAssertionFailure("updated->IsInitialized()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1061); AnnotateMozCrashReason("MOZ_ASSERT" "(" "updated->IsInitialized()" ")"); do { ((volatile int)__null) = 1061; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1062	updated->MarkDirty();
1063
1064	if (aFrecency) {
1065	updated->SetFrecency(*aFrecency);
1066	}
1067
1068	if (aHasAltData) {
1069	updated->SetHasAltData(*aHasAltData);
1070	}
1071
1072	if (aOnStartTime) {
1073	updated->SetOnStartTime(*aOnStartTime);
1074	}
1075
1076	if (aOnStopTime) {
1077	updated->SetOnStopTime(*aOnStopTime);
1078	}
1079
1080	if (aContentType) {
1081	updated->SetContentType(*aContentType);
1082	}
1083
1084	if (aSize) {
1085	updated->SetFileSize(*aSize);
1086	}
1087	}
1088	}
1089
1090	index->WriteIndexToDiskIfNeeded(lock);
1091
1092	return NS_OK;
1093	}
1094
1095	// static
1096	nsresult CacheIndex::RemoveAll() {
1097	LOG(("CacheIndex::RemoveAll()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAll()" ); } } while (0);
1098
1099	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1099); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 1099; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1100
1101	nsCOMPtr<nsIFile> file;
1102
1103	{
1104	StaticMutexAutoLock lock(sLock);
1105
1106	RefPtr<CacheIndex> index = gInstance;
1107
1108	if (!index) {
1109	return NS_ERROR_NOT_INITIALIZED;
1110	}
1111
1112	MOZ_ASSERT(!index->mRemovingAll)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!index->mRemovingAll)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!index->mRemovingAll))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("!index->mRemovingAll" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1112); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!index->mRemovingAll" ")"); do { ((volatile int)__null) = 1112; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1113
1114	if (!index->IsIndexUsable()) {
1115	return NS_ERROR_NOT_AVAILABLE;
1116	}
1117
1118	AutoRestore<bool> saveRemovingAll(index->mRemovingAll);
1119	index->mRemovingAll = true;
1120
1121	// Doom index and journal handles but don't null them out since this will be
1122	// done in FinishWrite/FinishRead methods.
1123	if (index->mIndexHandle) {
1124	CacheFileIOManager::DoomFile(index->mIndexHandle, nullptr);
1125	} else {
1126	// We don't have a handle to index file, so get the file here, but delete
1127	// it outside the lock. Ignore the result since this is not fatal.
1128	index->GetFile(nsLiteralCString(INDEX_NAME"index"), getter_AddRefs(file));
1129	}
1130
1131	if (index->mJournalHandle) {
1132	CacheFileIOManager::DoomFile(index->mJournalHandle, nullptr);
1133	}
1134
1135	switch (index->mState) {
1136	case WRITING:
1137	index->FinishWrite(false, lock);
1138	break;
1139	case READY:
1140	// nothing to do
1141	break;
1142	case READING:
1143	index->FinishRead(false, lock);
1144	break;
1145	case BUILDING:
1146	case UPDATING:
1147	index->FinishUpdate(false, lock);
1148	break;
1149	default:
1150	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1150); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 1150 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
1151	}
1152
1153	// We should end up in READY state
1154	MOZ_ASSERT(index->mState == READY)do { static_assert( mozilla::detail::AssertionConditionType< decltype(index->mState == READY)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(index->mState == READY))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("index->mState == READY" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1154); AnnotateMozCrashReason("MOZ_ASSERT" "(" "index->mState == READY" ")"); do { ((volatile int)__null) = 1154; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1155
1156	// There should not be any handle
1157	MOZ_ASSERT(!index->mIndexHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!index->mIndexHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!index->mIndexHandle))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("!index->mIndexHandle" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1157); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!index->mIndexHandle" ")"); do { ((volatile int)__null) = 1157; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1158	MOZ_ASSERT(!index->mJournalHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!index->mJournalHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!index->mJournalHandle))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("!index->mJournalHandle" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1158); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!index->mJournalHandle" ")"); do { ((volatile int)__null) = 1158; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1159
1160	index->mIndexOnDiskIsValid = false;
1161	index->mIndexNeedsUpdate = false;
1162
1163	index->mIndexStats.Clear();
1164	index->mFrecencyArray.Clear(lock);
1165	index->mIndex.Clear();
1166
1167	for (uint32_t i = 0; i < index->mIterators.Length();) {
1168	nsresult rv = index->mIterators[i]->CloseInternal(NS_ERROR_NOT_AVAILABLE);
1169	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1170	// CacheIndexIterator::CloseInternal() removes itself from mIterators
1171	// iff it returns success.
1172	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAll() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
1173	("CacheIndex::RemoveAll() - Failed to remove iterator %p. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAll() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
1174	"[rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAll() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0)
1175	index->mIterators[i], static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAll() - Failed to remove iterator %p. " "[rv=0x%08" "x" "]", index->mIterators[i], static_cast< uint32_t>(rv)); } } while (0);
1176	i++;
1177	}
1178	}
1179	}
1180
1181	if (file) {
1182	// Ignore the result. The file might not exist and the failure is not fatal.
1183	file->Remove(false);
1184	}
1185
1186	return NS_OK;
1187	}
1188
1189	// static
1190	nsresult CacheIndex::HasEntry(
1191	const nsACString& aKey, EntryStatus* _retval,
1192	const std::function<void(const CacheIndexEntry*)>& aCB) {
1193	LOG(("CacheIndex::HasEntry() [key=%s]", PromiseFlatCString(aKey).get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::HasEntry() [key=%s]" , TPromiseFlatString<char>(aKey).get()); } } while (0);
1194
1195	SHA1Sum sum;
1196	SHA1Sum::Hash hash;
1197	sum.update(aKey.BeginReading(), aKey.Length());
1198	sum.finish(hash);
1199
1200	return HasEntry(hash, _retval, aCB);
1201	}
1202
1203	// static
1204	nsresult CacheIndex::HasEntry(
1205	const SHA1Sum::Hash& hash, EntryStatus* _retval,
1206	const std::function<void(const CacheIndexEntry*)>& aCB) {
1207	StaticMutexAutoLock lock(sLock);
1208
1209	RefPtr<CacheIndex> index = gInstance;
1210
1211	if (!index) {
1212	return NS_ERROR_NOT_INITIALIZED;
1213	}
1214
1215	if (!index->IsIndexUsable()) {
1216	return NS_ERROR_NOT_AVAILABLE;
1217	}
1218
1219	const CacheIndexEntry* entry = nullptr;
1220
1221	switch (index->mState) {
1222	case READING:
1223	case WRITING:
1224	entry = index->mPendingUpdates.GetEntry(hash);
1225	[[fallthrough]];
1226	case BUILDING:
1227	case UPDATING:
1228	case READY:
1229	if (!entry) {
1230	entry = index->mIndex.GetEntry(hash);
1231	}
1232	break;
1233	case INITIAL:
1234	case SHUTDOWN:
1235	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1235); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 1235 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
1236	}
1237
1238	if (!entry) {
1239	if (index->mState == READY \|\| index->mState == WRITING) {
1240	*_retval = DOES_NOT_EXIST;
1241	} else {
1242	*_retval = DO_NOT_KNOW;
1243	}
1244	} else {
1245	if (entry->IsRemoved()) {
1246	if (entry->IsFresh()) {
1247	*_retval = DOES_NOT_EXIST;
1248	} else {
1249	*_retval = DO_NOT_KNOW;
1250	}
1251	} else {
1252	*_retval = EXISTS;
1253	if (aCB) {
1254	aCB(entry);
1255	}
1256	}
1257	}
1258
1259	LOG(("CacheIndex::HasEntry() - result is %u", _retval))do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::HasEntry() - result is %u" , *_retval); } } while (0);
1260	return NS_OK;
1261	}
1262
1263	// static
1264	nsresult CacheIndex::GetEntryForEviction(bool aIgnoreEmptyEntries,
1265	SHA1Sum::Hash* aHash, uint32_t* aCnt) {
1266	LOG(("CacheIndex::GetEntryForEviction()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction()" ); } } while (0);
1267
1268	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1268); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 1268; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1269
1270	StaticMutexAutoLock lock(sLock);
1271
1272	RefPtr<CacheIndex> index = gInstance;
1273
1274	if (!index) return NS_ERROR_NOT_INITIALIZED;
1275
1276	if (!index->IsIndexUsable()) {
1277	return NS_ERROR_NOT_AVAILABLE;
1278	}
1279
1280	if (index->mIndexStats.Size() == 0) {
1281	return NS_ERROR_NOT_AVAILABLE;
1282	}
1283
1284	int32_t mediaUsage =
1285	round(static_cast<double>(index->mIndexStats.SizeByType(
1286	nsICacheEntry::CONTENT_TYPE_MEDIA)) *
1287	100.0 / static_cast<double>(index->mIndexStats.Size()));
1288	int32_t mediaUsageLimit =
1289	StaticPrefs::browser_cache_disk_content_type_media_limit();
1290	bool evictMedia = false;
1291	if (mediaUsage > mediaUsageLimit) {
1292	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - media content type is over the " "limit [mediaUsage=%d, mediaUsageLimit=%d]", mediaUsage, mediaUsageLimit ); } } while (0)
1293	("CacheIndex::GetEntryForEviction() - media content type is over the "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - media content type is over the " "limit [mediaUsage=%d, mediaUsageLimit=%d]", mediaUsage, mediaUsageLimit ); } } while (0)
1294	"limit [mediaUsage=%d, mediaUsageLimit=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - media content type is over the " "limit [mediaUsage=%d, mediaUsageLimit=%d]", mediaUsage, mediaUsageLimit ); } } while (0)
1295	mediaUsage, mediaUsageLimit))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - media content type is over the " "limit [mediaUsage=%d, mediaUsageLimit=%d]", mediaUsage, mediaUsageLimit ); } } while (0);
1296	evictMedia = true;
1297	}
1298
1299	SHA1Sum::Hash hash;
1300	CacheIndexRecord* foundRecord = nullptr;
1301	uint32_t skipped = 0;
1302
1303	// find first non-forced valid and unpinned entry with the lowest frecency
1304	index->mFrecencyArray.SortIfNeeded(lock);
1305
1306	for (auto iter = index->mFrecencyArray.Iter(); !iter.Done(); iter.Next()) {
1307	CacheIndexRecord* rec = iter.Get()->Get();
1308
1309	memcpy(&hash, rec->mHash, sizeof(SHA1Sum::Hash));
1310
1311	++skipped;
1312
1313	if (evictMedia && CacheIndexEntry::GetContentType(rec) !=
1314	nsICacheEntry::CONTENT_TYPE_MEDIA) {
1315	continue;
1316	}
1317
1318	if (IsForcedValidEntry(&hash)) {
1319	continue;
1320	}
1321
1322	if (CacheIndexEntry::IsPinned(rec)) {
1323	continue;
1324	}
1325
1326	if (aIgnoreEmptyEntries && !CacheIndexEntry::GetFileSize(*rec)) {
1327	continue;
1328	}
1329
1330	--skipped;
1331	foundRecord = rec;
1332	break;
1333	}
1334
1335	if (!foundRecord) return NS_ERROR_NOT_AVAILABLE;
1336
1337	*aCnt = skipped;
1338
1339	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - returning entry " "[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]" , PR_htonl((reinterpret_cast<const uint32_t>(&hash ))[0]), PR_htonl((reinterpret_cast<const uint32_t>(& hash))[1]), PR_htonl((reinterpret_cast<const uint32_t> (&hash))[2]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[3]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[4]), aCnt, foundRecord->mFrecency, CacheIndexEntry ::GetContentType(foundRecord)); } } while (0)
1340	("CacheIndex::GetEntryForEviction() - returning entry "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - returning entry " "[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]" , PR_htonl((reinterpret_cast<const uint32_t>(&hash ))[0]), PR_htonl((reinterpret_cast<const uint32_t>(& hash))[1]), PR_htonl((reinterpret_cast<const uint32_t> (&hash))[2]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[3]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[4]), aCnt, foundRecord->mFrecency, CacheIndexEntry ::GetContentType(foundRecord)); } } while (0)
1341	"[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - returning entry " "[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]" , PR_htonl((reinterpret_cast<const uint32_t>(&hash ))[0]), PR_htonl((reinterpret_cast<const uint32_t>(& hash))[1]), PR_htonl((reinterpret_cast<const uint32_t> (&hash))[2]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[3]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[4]), aCnt, foundRecord->mFrecency, CacheIndexEntry ::GetContentType(foundRecord)); } } while (0)
1342	LOGSHA1(&hash), aCnt, foundRecord->mFrecency,do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - returning entry " "[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]" , PR_htonl((reinterpret_cast<const uint32_t>(&hash ))[0]), PR_htonl((reinterpret_cast<const uint32_t>(& hash))[1]), PR_htonl((reinterpret_cast<const uint32_t> (&hash))[2]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[3]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[4]), aCnt, foundRecord->mFrecency, CacheIndexEntry ::GetContentType(foundRecord)); } } while (0)
1343	CacheIndexEntry::GetContentType(foundRecord)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryForEviction() - returning entry " "[hash=%08x%08x%08x%08x%08x, cnt=%u, frecency=%u, contentType=%u]" , PR_htonl((reinterpret_cast<const uint32_t>(&hash ))[0]), PR_htonl((reinterpret_cast<const uint32_t>(& hash))[1]), PR_htonl((reinterpret_cast<const uint32_t> (&hash))[2]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[3]), PR_htonl((reinterpret_cast<const uint32_t >(&hash))[4]), aCnt, foundRecord->mFrecency, CacheIndexEntry ::GetContentType(foundRecord)); } } while (0);
1344
1345	memcpy(aHash, &hash, sizeof(SHA1Sum::Hash));
1346
1347	return NS_OK;
1348	}
1349
1350	// static
1351	bool CacheIndex::IsForcedValidEntry(const SHA1Sum::Hash* aHash) {
1352	RefPtr<CacheFileHandle> handle;
1353
1354	CacheFileIOManager::gInstance->mHandles.GetHandle(aHash,
1355	getter_AddRefs(handle));
1356
1357	if (!handle) return false;
1358
1359	nsCString hashKey = handle->Key();
1360	return CacheStorageService::Self()->IsForcedValidEntry(hashKey);
1361	}
1362
1363	// static
1364	nsresult CacheIndex::GetCacheSize(uint32_t* _retval) {
1365	LOG(("CacheIndex::GetCacheSize()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetCacheSize()" ); } } while (0);
1366
1367	StaticMutexAutoLock lock(sLock);
1368
1369	RefPtr<CacheIndex> index = gInstance;
1370
1371	if (!index) return NS_ERROR_NOT_INITIALIZED;
1372
1373	if (!index->IsIndexUsable()) {
1374	return NS_ERROR_NOT_AVAILABLE;
1375	}
1376
1377	*_retval = index->mIndexStats.Size();
1378	LOG(("CacheIndex::GetCacheSize() - returning %u", _retval))do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetCacheSize() - returning %u" , *_retval); } } while (0);
1379	return NS_OK;
1380	}
1381
1382	// static
1383	nsresult CacheIndex::GetEntryFileCount(uint32_t* _retval) {
1384	LOG(("CacheIndex::GetEntryFileCount()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryFileCount()" ); } } while (0);
1385
1386	StaticMutexAutoLock lock(sLock);
1387
1388	RefPtr<CacheIndex> index = gInstance;
1389
1390	if (!index) {
1391	return NS_ERROR_NOT_INITIALIZED;
1392	}
1393
1394	if (!index->IsIndexUsable()) {
1395	return NS_ERROR_NOT_AVAILABLE;
1396	}
1397
1398	*_retval = index->mIndexStats.ActiveEntriesCount();
1399	LOG(("CacheIndex::GetEntryFileCount() - returning %u", _retval))do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetEntryFileCount() - returning %u" , *_retval); } } while (0);
1400	return NS_OK;
1401	}
1402
1403	// static
1404	nsresult CacheIndex::GetCacheStats(nsILoadContextInfo* aInfo, uint32_t* aSize,
1405	uint32_t* aCount) {
1406	LOG(("CacheIndex::GetCacheStats() [info=%p]", aInfo))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetCacheStats() [info=%p]" , aInfo); } } while (0);
1407
1408	StaticMutexAutoLock lock(sLock);
1409
1410	RefPtr<CacheIndex> index = gInstance;
1411
1412	if (!index) {
1413	return NS_ERROR_NOT_INITIALIZED;
1414	}
1415
1416	if (!index->IsIndexUsable()) {
1417	return NS_ERROR_NOT_AVAILABLE;
1418	}
1419
1420	*aSize = 0;
1421	*aCount = 0;
1422
1423	for (auto iter = index->mFrecencyArray.Iter(); !iter.Done(); iter.Next()) {
1424	if (aInfo &&
1425	!CacheIndexEntry::RecordMatchesLoadContextInfo(iter.Get(), aInfo)) {
1426	continue;
1427	}
1428
1429	aSize += CacheIndexEntry::GetFileSize((iter.Get()->Get()));
1430	++*aCount;
1431	}
1432
1433	return NS_OK;
1434	}
1435
1436	// static
1437	nsresult CacheIndex::AsyncGetDiskConsumption(
1438	nsICacheStorageConsumptionObserver* aObserver) {
1439	LOG(("CacheIndex::AsyncGetDiskConsumption()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AsyncGetDiskConsumption()" ); } } while (0);
1440
1441	StaticMutexAutoLock lock(sLock);
1442
1443	RefPtr<CacheIndex> index = gInstance;
1444
1445	if (!index) {
1446	return NS_ERROR_NOT_INITIALIZED;
1447	}
1448
1449	if (!index->IsIndexUsable()) {
1450	return NS_ERROR_NOT_AVAILABLE;
1451	}
1452
1453	RefPtr<DiskConsumptionObserver> observer =
1454	DiskConsumptionObserver::Init(aObserver);
1455
1456	NS_ENSURE_ARG(observer)do { if ((__builtin_expect(!!(!(observer)), 0))) { NS_DebugBreak (NS_DEBUG_WARNING, "NS_ENSURE_TRUE(" "observer" ") failed", nullptr , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1456); return NS_ERROR_INVALID_ARG; } } while (false);
1457
1458	if ((index->mState == READY \|\| index->mState == WRITING) &&
1459	!index->mAsyncGetDiskConsumptionBlocked) {
1460	LOG(("CacheIndex::AsyncGetDiskConsumption - calling immediately"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AsyncGetDiskConsumption - calling immediately" ); } } while (0);
1461	// Safe to call the callback under the lock,
1462	// we always post to the main thread.
1463	observer->OnDiskConsumption(index->mIndexStats.Size() << 10);
1464	return NS_OK;
1465	}
1466
1467	LOG(("CacheIndex::AsyncGetDiskConsumption - remembering callback"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::AsyncGetDiskConsumption - remembering callback" ); } } while (0);
1468	// Will be called when the index get to the READY state.
1469	index->mDiskConsumptionObservers.AppendElement(observer);
1470
1471	// Move forward with index re/building if it is pending
1472	RefPtr<CacheIOThread> ioThread = CacheFileIOManager::IOThread();
1473	if (ioThread) {
1474	ioThread->Dispatch(
1475	NS_NewRunnableFunction("net::CacheIndex::AsyncGetDiskConsumption",
1476	[]() -> void {
1477	StaticMutexAutoLock lock(sLock);
1478
1479	RefPtr<CacheIndex> index = gInstance;
1480	if (index && index->mUpdateTimer) {
1481	index->mUpdateTimer->Cancel();
1482	index->DelayedUpdateLocked(lock);
1483	}
1484	}),
1485	CacheIOThread::INDEX);
1486	}
1487
1488	return NS_OK;
1489	}
1490
1491	// static
1492	nsresult CacheIndex::GetIterator(nsILoadContextInfo* aInfo, bool aAddNew,
1493	CacheIndexIterator** _retval) {
1494	LOG(("CacheIndex::GetIterator() [info=%p, addNew=%d]", aInfo, aAddNew))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::GetIterator() [info=%p, addNew=%d]" , aInfo, aAddNew); } } while (0);
1495
1496	StaticMutexAutoLock lock(sLock);
1497
1498	RefPtr<CacheIndex> index = gInstance;
1499
1500	if (!index) {
1501	return NS_ERROR_NOT_INITIALIZED;
1502	}
1503
1504	if (!index->IsIndexUsable()) {
1505	return NS_ERROR_NOT_AVAILABLE;
1506	}
1507
1508	RefPtr<CacheIndexIterator> idxIter;
1509	if (aInfo) {
1510	idxIter = new CacheIndexContextIterator(index, aAddNew, aInfo);
1511	} else {
1512	idxIter = new CacheIndexIterator(index, aAddNew);
1513	}
1514
1515	index->mFrecencyArray.SortIfNeeded(lock);
1516
1517	for (auto iter = index->mFrecencyArray.Iter(); !iter.Done(); iter.Next()) {
1518	idxIter->AddRecord(iter.Get(), lock);
1519	}
1520
1521	index->mIterators.AppendElement(idxIter);
1522	idxIter.swap(*_retval);
1523	return NS_OK;
1524	}
1525
1526	// static
1527	nsresult CacheIndex::IsUpToDate(bool* _retval) {
1528	LOG(("CacheIndex::IsUpToDate()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsUpToDate()" ); } } while (0);
1529
1530	StaticMutexAutoLock lock(sLock);
1531
1532	RefPtr<CacheIndex> index = gInstance;
1533
1534	if (!index) {
1535	return NS_ERROR_NOT_INITIALIZED;
1536	}
1537
1538	if (!index->IsIndexUsable()) {
1539	return NS_ERROR_NOT_AVAILABLE;
1540	}
1541
1542	*_retval = (index->mState == READY \|\| index->mState == WRITING) &&
1543	!index->mIndexNeedsUpdate && !index->mShuttingDown;
1544
1545	LOG(("CacheIndex::IsUpToDate() - returning %d", _retval))do { const ::mozilla::LogModule moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsUpToDate() - returning %d" , *_retval); } } while (0);
1546	return NS_OK;
1547	}
1548
1549	bool CacheIndex::IsIndexUsable() {
1550	MOZ_ASSERT(mState != INITIAL)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState != INITIAL)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState != INITIAL))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState != INITIAL" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1550); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState != INITIAL" ")"); do { ((volatile int)__null) = 1550; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1551
1552	switch (mState) {
1553	case INITIAL:
1554	case SHUTDOWN:
1555	return false;
1556
1557	case READING:
1558	case WRITING:
1559	case BUILDING:
1560	case UPDATING:
1561	case READY:
1562	break;
1563	}
1564
1565	return true;
1566	}
1567
1568	// static
1569	bool CacheIndex::IsCollision(CacheIndexEntry* aEntry,
1570	OriginAttrsHash aOriginAttrsHash,
1571	bool aAnonymous) {
1572	if (!aEntry->IsInitialized()) {
1573	return false;
1574	}
1575
1576	if (aEntry->Anonymous() != aAnonymous \|\|
1577	aEntry->OriginAttrsHash() != aOriginAttrsHash) {
1578	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1579	("CacheIndex::IsCollision() - Collision detected for entry hash=%08x"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1580	"%08x%08x%08x%08x, expected values: originAttrsHash=%" PRIu64 ", "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1581	"anonymous=%d; actual values: originAttrsHash=%" PRIu64do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1582	", anonymous=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1583	LOGSHA1(aEntry->Hash()), aOriginAttrsHash, aAnonymous,do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0)
1584	aEntry->OriginAttrsHash(), aEntry->Anonymous()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::IsCollision() - Collision detected for entry hash=%08x" "%08x%08x%08x%08x, expected values: originAttrsHash=%" "l" "u" ", " "anonymous=%d; actual values: originAttrsHash=%" "l" "u" ", anonymous=%d]", PR_htonl((reinterpret_cast<const uint32_t >(aEntry->Hash()))[0]), PR_htonl((reinterpret_cast< const uint32_t>(aEntry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(aEntry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aEntry->Hash()))[4]), aOriginAttrsHash , aAnonymous, aEntry->OriginAttrsHash(), aEntry->Anonymous ()); } } while (0);
1585	return true;
1586	}
1587
1588	return false;
1589	}
1590
1591	// static
1592	bool CacheIndex::HasEntryChanged(
1593	CacheIndexEntry* aEntry, const uint32_t* aFrecency, const bool* aHasAltData,
1594	const uint16_t* aOnStartTime, const uint16_t* aOnStopTime,
1595	const uint8_t* aContentType, const uint32_t* aSize) {
1596	if (aFrecency && *aFrecency != aEntry->GetFrecency()) {
1597	return true;
1598	}
1599
1600	if (aHasAltData && *aHasAltData != aEntry->GetHasAltData()) {
1601	return true;
1602	}
1603
1604	if (aOnStartTime && *aOnStartTime != aEntry->GetOnStartTime()) {
1605	return true;
1606	}
1607
1608	if (aOnStopTime && *aOnStopTime != aEntry->GetOnStopTime()) {
1609	return true;
1610	}
1611
1612	if (aContentType && *aContentType != aEntry->GetContentType()) {
1613	return true;
1614	}
1615
1616	if (aSize &&
1617	(*aSize & CacheIndexEntry::kFileSizeMask) != aEntry->GetFileSize()) {
1618	return true;
1619	}
1620
1621	return false;
1622	}
1623
1624	void CacheIndex::ProcessPendingOperations(
1625	const StaticMutexAutoLock& aProofOfLock) {
1626	sLock.AssertCurrentThreadOwns();
1627	LOG(("CacheIndex::ProcessPendingOperations()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ProcessPendingOperations()" ); } } while (0);
1628
1629	for (auto iter = mPendingUpdates.Iter(); !iter.Done(); iter.Next()) {
1630	CacheIndexEntryUpdate* update = iter.Get();
1631
1632	LOG(("CacheIndex::ProcessPendingOperations() [hash=%08x%08x%08x%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ProcessPendingOperations() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(update-> Hash()))[0]), PR_htonl((reinterpret_cast<const uint32_t> (update->Hash()))[1]), PR_htonl((reinterpret_cast<const uint32_t>(update->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(update->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(update->Hash()))[4])); } } while ( 0)
1633	LOGSHA1(update->Hash())))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ProcessPendingOperations() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(update-> Hash()))[0]), PR_htonl((reinterpret_cast<const uint32_t> (update->Hash()))[1]), PR_htonl((reinterpret_cast<const uint32_t>(update->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(update->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(update->Hash()))[4])); } } while ( 0);
1634
1635	MOZ_ASSERT(update->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(update->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(update->IsFresh()))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("update->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1635); AnnotateMozCrashReason("MOZ_ASSERT" "(" "update->IsFresh()" ")"); do { ((volatile int)__null) = 1635; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1636
1637	CacheIndexEntry* entry = mIndex.GetEntry(*update->Hash());
1638	{
1639	CacheIndexEntryAutoManage emng(update->Hash(), this, aProofOfLock);
1640	emng.DoNotSearchInUpdates();
1641
1642	if (update->IsRemoved()) {
1643	if (entry) {
1644	if (entry->IsRemoved()) {
1645	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1645); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 1645; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1646	MOZ_ASSERT(entry->IsDirty())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsDirty())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsDirty()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsDirty()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1646); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsDirty()" ")"); do { ((volatile int)__null) = 1646; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1647	} else if (!entry->IsDirty() && entry->IsFileEmpty()) {
1648	// Entries with empty file are not stored in index on disk. Just
1649	// remove the entry, but only in case the entry is not dirty, i.e.
1650	// the entry file was empty when we wrote the index.
1651	mIndex.RemoveEntry(entry);
1652	entry = nullptr;
1653	} else {
1654	entry->MarkRemoved();
1655	entry->MarkDirty();
1656	entry->MarkFresh();
1657	}
1658	}
1659	} else if (entry) {
1660	// Some information in mIndex can be newer than in mPendingUpdates (see
1661	// bug 1074832). This will copy just those values that were really
1662	// updated.
1663	update->ApplyUpdate(entry);
1664	} else {
1665	// There is no entry in mIndex, copy all information from
1666	// mPendingUpdates to mIndex.
1667	entry = mIndex.PutEntry(*update->Hash());
1668	entry = update;
1669	}
1670	}
1671	iter.Remove();
1672	}
1673
1674	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1674); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 1674; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1675
1676	EnsureCorrectStats();
1677	}
1678
1679	bool CacheIndex::WriteIndexToDiskIfNeeded(
1680	const StaticMutexAutoLock& aProofOfLock) {
1681	sLock.AssertCurrentThreadOwns();
1682	if (mState != READY \|\| mShuttingDown \|\| mRWPending) {
1683	return false;
1684	}
1685
1686	if (!mLastDumpTime.IsNull() &&
1687	(TimeStamp::NowLoRes() - mLastDumpTime).ToMilliseconds() <
1688	kMinDumpInterval20000) {
1689	return false;
1690	}
1691
1692	if (mIndexStats.Dirty() < kMinUnwrittenChanges300) {
1693	return false;
1694	}
1695
1696	WriteIndexToDisk(aProofOfLock);
1697	return true;
1698	}
1699
1700	void CacheIndex::WriteIndexToDisk(const StaticMutexAutoLock& aProofOfLock) {
1701	sLock.AssertCurrentThreadOwns();
1702	LOG(("CacheIndex::WriteIndexToDisk()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteIndexToDisk()" ); } } while (0);
1703	mIndexStats.Log();
1704
1705	nsresult rv;
1706
1707	MOZ_ASSERT(mState == READY)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == READY)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == READY))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == READY" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1707); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == READY" ")"); do { ((volatile int)__null) = 1707; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1708	MOZ_ASSERT(!mRWBuf)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWBuf)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWBuf))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWBuf", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1708); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWBuf" ")" ); do { ((volatile int)__null) = 1708; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1709	MOZ_ASSERT(!mRWHash)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWHash)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWHash))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWHash", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1709); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWHash" ")" ); do { ((volatile int)__null) = 1709; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1710	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1710); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 1710; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1711
1712	ChangeState(WRITING, aProofOfLock);
1713
1714	mProcessEntries = mIndexStats.ActiveEntriesCount();
1715
1716	mIndexFileOpener = new FileOpenHelper(this);
1717	rv = CacheFileIOManager::OpenFile(
1718	nsLiteralCString(TEMP_INDEX_NAME"index.tmp"),
1719	CacheFileIOManager::SPECIAL_FILE \| CacheFileIOManager::CREATE,
1720	mIndexFileOpener);
1721	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1722	LOG(("CacheIndex::WriteIndexToDisk() - Can't open file [rv=0x%08" PRIx32do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteIndexToDisk() - Can't open file [rv=0x%08" "x" "]", static_cast<uint32_t>(rv)); } } while (0)
1723	"]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteIndexToDisk() - Can't open file [rv=0x%08" "x" "]", static_cast<uint32_t>(rv)); } } while (0)
1724	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteIndexToDisk() - Can't open file [rv=0x%08" "x" "]", static_cast<uint32_t>(rv)); } } while (0);
1725	FinishWrite(false, aProofOfLock);
1726	return;
1727	}
1728
1729	// Write index header to a buffer, it will be written to disk together with
1730	// records in WriteRecords() once we open the file successfully.
1731	AllocBuffer();
1732	mRWHash = new CacheHash();
1733
1734	mRWBufPos = 0;
1735	// index version
1736	NetworkEndian::writeUint32(mRWBuf + mRWBufPos, kIndexVersion0x0000000A);
1737	mRWBufPos += sizeof(uint32_t);
1738	// timestamp
1739	NetworkEndian::writeUint32(mRWBuf + mRWBufPos,
1740	static_cast<uint32_t>(PR_Now() / PR_USEC_PER_SEC1000000L));
1741	mRWBufPos += sizeof(uint32_t);
1742	// dirty flag
1743	NetworkEndian::writeUint32(mRWBuf + mRWBufPos, 1);
1744	mRWBufPos += sizeof(uint32_t);
1745	// amount of data written to the cache
1746	NetworkEndian::writeUint32(mRWBuf + mRWBufPos,
1747	static_cast<uint32_t>(mTotalBytesWritten >> 10));
1748	mRWBufPos += sizeof(uint32_t);
1749
1750	mSkipEntries = 0;
1751	}
1752
1753	void CacheIndex::WriteRecords(const StaticMutexAutoLock& aProofOfLock) {
1754	sLock.AssertCurrentThreadOwns();
1755	LOG(("CacheIndex::WriteRecords()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteRecords()" ); } } while (0);
1756
1757	nsresult rv;
1758
1759	MOZ_ASSERT(mState == WRITING)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == WRITING)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == WRITING))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == WRITING" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1759); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == WRITING" ")"); do { ((volatile int)__null) = 1759; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1760	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1760); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 1760; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1761
1762	int64_t fileOffset;
1763
1764	if (mSkipEntries) {
1765	MOZ_ASSERT(mRWBufPos == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWBufPos == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRWBufPos == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWBufPos == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1765); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRWBufPos == 0" ")"); do { ((volatile int)__null) = 1765; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1766	fileOffset = sizeof(CacheIndexHeader);
1767	fileOffset += sizeof(CacheIndexRecord) * mSkipEntries;
1768	} else {
1769	MOZ_ASSERT(mRWBufPos == sizeof(CacheIndexHeader))do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWBufPos == sizeof(CacheIndexHeader))>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(! !(mRWBufPos == sizeof(CacheIndexHeader)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWBufPos == sizeof(CacheIndexHeader)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1769); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRWBufPos == sizeof(CacheIndexHeader)" ")"); do { ((volatile int)__null) = 1769; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1770	fileOffset = 0;
1771	}
1772	uint32_t hashOffset = mRWBufPos;
1773
1774	char* buf = mRWBuf + mRWBufPos;
1775	uint32_t skip = mSkipEntries;
1776	uint32_t processMax = (mRWBufSize - mRWBufPos) / sizeof(CacheIndexRecord);
1777	MOZ_ASSERT(processMax != 0 \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype(processMax != 0 \|\| mProcessEntries == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(processMax != 0 \|\| mProcessEntries == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("processMax != 0 \|\| mProcessEntries == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1779); AnnotateMozCrashReason("MOZ_ASSERT" "(" "processMax != 0 \|\| mProcessEntries == 0" ")"); do { ((volatile int)__null) = 1779; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
1778	mProcessEntries ==do { static_assert( mozilla::detail::AssertionConditionType< decltype(processMax != 0 \|\| mProcessEntries == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(processMax != 0 \|\| mProcessEntries == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("processMax != 0 \|\| mProcessEntries == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1779); AnnotateMozCrashReason("MOZ_ASSERT" "(" "processMax != 0 \|\| mProcessEntries == 0" ")"); do { ((volatile int)__null) = 1779; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
1779	0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(processMax != 0 \|\| mProcessEntries == 0)>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(processMax != 0 \|\| mProcessEntries == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("processMax != 0 \|\| mProcessEntries == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1779); AnnotateMozCrashReason("MOZ_ASSERT" "(" "processMax != 0 \|\| mProcessEntries == 0" ")"); do { ((volatile int)__null) = 1779; __attribute__((nomerge )) ::abort(); } while (false); } } while (false); // TODO make sure we can write an empty index
1780	uint32_t processed = 0;
1781	#ifdef DEBUG1
1782	bool hasMore = false;
1783	#endif
1784	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
1785	CacheIndexEntry* entry = iter.Get();
1786	if (entry->IsRemoved() \|\| !entry->IsInitialized() \|\| entry->IsFileEmpty()) {
1787	continue;
1788	}
1789
1790	if (skip) {
1791	skip--;
1792	continue;
1793	}
1794
1795	if (processed == processMax) {
1796	#ifdef DEBUG1
1797	hasMore = true;
1798	#endif
1799	break;
1800	}
1801
1802	entry->WriteToBuf(buf);
1803	buf += sizeof(CacheIndexRecord);
1804	processed++;
1805	}
1806
1807	MOZ_ASSERT(mRWBufPos != static_cast<uint32_t>(buf - mRWBuf) \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWBufPos != static_cast<uint32_t>(buf - mRWBuf ) \|\| mProcessEntries == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRWBufPos != static_cast< uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWBufPos != static_cast<uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1808); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRWBufPos != static_cast<uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0" ")"); do { ((volatile int)__null) = 1808; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
1808	mProcessEntries == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWBufPos != static_cast<uint32_t>(buf - mRWBuf ) \|\| mProcessEntries == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRWBufPos != static_cast< uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWBufPos != static_cast<uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1808); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mRWBufPos != static_cast<uint32_t>(buf - mRWBuf) \|\| mProcessEntries == 0" ")"); do { ((volatile int)__null) = 1808; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1809	mRWBufPos = buf - mRWBuf;
1810	mSkipEntries += processed;
1811	MOZ_ASSERT(mSkipEntries <= mProcessEntries)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mSkipEntries <= mProcessEntries)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mSkipEntries <= mProcessEntries ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mSkipEntries <= mProcessEntries", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1811); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mSkipEntries <= mProcessEntries" ")"); do { ((volatile int)__null) = 1811; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1812
1813	mRWHash->Update(mRWBuf + hashOffset, mRWBufPos - hashOffset);
1814
1815	if (mSkipEntries == mProcessEntries) {
1816	MOZ_ASSERT(!hasMore)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!hasMore)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!hasMore))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!hasMore", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1816); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!hasMore" ")" ); do { ((volatile int)__null) = 1816; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1817
1818	// We've processed all records
1819	if (mRWBufPos + sizeof(CacheHash::Hash32_t) > mRWBufSize) {
1820	// realloc buffer to spare another write cycle
1821	mRWBufSize = mRWBufPos + sizeof(CacheHash::Hash32_t);
1822	mRWBuf = static_cast<char*>(moz_xrealloc(mRWBuf, mRWBufSize));
1823	}
1824
1825	NetworkEndian::writeUint32(mRWBuf + mRWBufPos, mRWHash->GetHash());
1826	mRWBufPos += sizeof(CacheHash::Hash32_t);
1827	} else {
1828	MOZ_ASSERT(hasMore)do { static_assert( mozilla::detail::AssertionConditionType< decltype(hasMore)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(hasMore))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("hasMore", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1828); AnnotateMozCrashReason("MOZ_ASSERT" "(" "hasMore" ")" ); do { ((volatile int)__null) = 1828; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1829	}
1830
1831	rv = CacheFileIOManager::Write(mIndexHandle, fileOffset, mRWBuf, mRWBufPos,
1832	mSkipEntries == mProcessEntries, false, this);
1833	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
1834	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteRecords() - CacheFileIOManager::Write() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
1835	("CacheIndex::WriteRecords() - CacheFileIOManager::Write() failed "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteRecords() - CacheFileIOManager::Write() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
1836	"synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteRecords() - CacheFileIOManager::Write() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
1837	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteRecords() - CacheFileIOManager::Write() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0);
1838	FinishWrite(false, aProofOfLock);
1839	} else {
1840	mRWPending = true;
1841	}
1842
1843	mRWBufPos = 0;
1844	}
1845
1846	void CacheIndex::FinishWrite(bool aSucceeded,
1847	const StaticMutexAutoLock& aProofOfLock) {
1848	sLock.AssertCurrentThreadOwns();
1849	LOG(("CacheIndex::FinishWrite() [succeeded=%d]", aSucceeded))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishWrite() [succeeded=%d]" , aSucceeded); } } while (0);
1850
1851	MOZ_ASSERT((!aSucceeded && mState == SHUTDOWN) \|\| mState == WRITING)do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && mState == SHUTDOWN) \|\| mState == WRITING)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!aSucceeded && mState == SHUTDOWN) \|\| mState == WRITING))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("(!aSucceeded && mState == SHUTDOWN) \|\| mState == WRITING" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1851); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && mState == SHUTDOWN) \|\| mState == WRITING" ")"); do { ((volatile int)__null) = 1851; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1852
1853	// If there is write operation pending we must be cancelling writing of the
1854	// index when shutting down or removing the whole index.
1855	MOZ_ASSERT(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll)))do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll)))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1855); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))" ")"); do { ((volatile int)__null) = 1855; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1856
1857	mIndexHandle = nullptr;
1858	mRWHash = nullptr;
1859	ReleaseBuffer();
1860
1861	if (aSucceeded) {
1862	// Opening of the file must not be in progress if writing succeeded.
1863	MOZ_ASSERT(!mIndexFileOpener)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mIndexFileOpener)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mIndexFileOpener))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mIndexFileOpener" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1863); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mIndexFileOpener" ")"); do { ((volatile int)__null) = 1863; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1864
1865	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
1866	CacheIndexEntry* entry = iter.Get();
1867
1868	bool remove = false;
1869	{
1870	CacheIndexEntryAutoManage emng(entry->Hash(), this, aProofOfLock);
1871
1872	if (entry->IsRemoved()) {
1873	emng.DoNotSearchInIndex();
1874	remove = true;
1875	} else if (entry->IsDirty()) {
1876	entry->ClearDirty();
1877	}
1878	}
1879	if (remove) {
1880	iter.Remove();
1881	}
1882	}
1883
1884	mIndexOnDiskIsValid = true;
1885	} else {
1886	if (mIndexFileOpener) {
1887	// If opening of the file is still in progress (e.g. WRITE process was
1888	// canceled by RemoveAll()) then we need to cancel the opener to make sure
1889	// that OnFileOpenedInternal() won't be called.
1890	mIndexFileOpener->Cancel();
1891	mIndexFileOpener = nullptr;
1892	}
1893	}
1894
1895	ProcessPendingOperations(aProofOfLock);
1896	mIndexStats.Log();
1897
1898	if (mState == WRITING) {
1899	ChangeState(READY, aProofOfLock);
1900	mLastDumpTime = TimeStamp::NowLoRes();
1901	}
1902	}
1903
1904	nsresult CacheIndex::GetFile(const nsACString& aName, nsIFile** _retval) {
1905	nsresult rv;
1906
1907	nsCOMPtr<nsIFile> file;
1908	rv = mCacheDirectory->Clone(getter_AddRefs(file));
1909	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1909); return rv; } } while (false);
1910
1911	rv = file->AppendNative(aName);
1912	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1912); return rv; } } while (false);
1913
1914	file.swap(*_retval);
1915	return NS_OK;
1916	}
1917
1918	void CacheIndex::RemoveFile(const nsACString& aName) {
1919	MOZ_ASSERT(mState == SHUTDOWN)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == SHUTDOWN)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == SHUTDOWN))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == SHUTDOWN" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1919); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == SHUTDOWN" ")"); do { ((volatile int)__null) = 1919; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1920
1921	nsresult rv;
1922
1923	nsCOMPtr<nsIFile> file;
1924	rv = GetFile(aName, getter_AddRefs(file));
1925	NS_ENSURE_SUCCESS_VOID(rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS_VOID(%s) failed with " "result 0x%" "X" "%s%s%s", "rv", static_cast<uint32_t> (__rv), name ? " (" : "", name ? name : "", name ? ")" : ""); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1925); return; } } while (false);
1926
1927	rv = file->Remove(false);
1928	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0))) && rv != NS_ERROR_FILE_NOT_FOUND) {
1929	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveFile() - Cannot remove old entry file from disk " "[rv=0x%08" "x" ", name=%s]", static_cast<uint32_t>(rv ), TPromiseFlatString<char>(aName).get()); } } while (0 )
1930	("CacheIndex::RemoveFile() - Cannot remove old entry file from disk "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveFile() - Cannot remove old entry file from disk " "[rv=0x%08" "x" ", name=%s]", static_cast<uint32_t>(rv ), TPromiseFlatString<char>(aName).get()); } } while (0 )
1931	"[rv=0x%08" PRIx32 ", name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveFile() - Cannot remove old entry file from disk " "[rv=0x%08" "x" ", name=%s]", static_cast<uint32_t>(rv ), TPromiseFlatString<char>(aName).get()); } } while (0 )
1932	static_cast<uint32_t>(rv), PromiseFlatCString(aName).get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveFile() - Cannot remove old entry file from disk " "[rv=0x%08" "x" ", name=%s]", static_cast<uint32_t>(rv ), TPromiseFlatString<char>(aName).get()); } } while (0 );
1933	}
1934	}
1935
1936	void CacheIndex::RemoveAllIndexFiles() {
1937	LOG(("CacheIndex::RemoveAllIndexFiles()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveAllIndexFiles()" ); } } while (0);
1938	RemoveFile(nsLiteralCString(INDEX_NAME"index"));
1939	RemoveJournalAndTempFile();
1940	}
1941
1942	void CacheIndex::RemoveJournalAndTempFile() {
1943	LOG(("CacheIndex::RemoveJournalAndTempFile()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveJournalAndTempFile()" ); } } while (0);
1944	RemoveFile(nsLiteralCString(TEMP_INDEX_NAME"index.tmp"));
1945	RemoveFile(nsLiteralCString(JOURNAL_NAME"index.log"));
1946	}
1947
1948	class WriteLogHelper {
1949	public:
1950	explicit WriteLogHelper(PRFileDesc* aFD)
1951	: mFD(aFD), mBufSize(kMaxBufSize16384), mBufPos(0) {
1952	mHash = new CacheHash();
1953	mBuf = static_cast<char*>(moz_xmalloc(mBufSize));
1954	}
1955
1956	~WriteLogHelper() { free(mBuf); }
1957
1958	nsresult AddEntry(CacheIndexEntry* aEntry);
1959	nsresult Finish();
1960
1961	private:
1962	nsresult FlushBuffer();
1963
1964	PRFileDesc* mFD;
1965	char* mBuf;
1966	uint32_t mBufSize;
1967	int32_t mBufPos;
1968	RefPtr<CacheHash> mHash;
1969	};
1970
1971	nsresult WriteLogHelper::AddEntry(CacheIndexEntry* aEntry) {
1972	nsresult rv;
1973
1974	if (mBufPos + sizeof(CacheIndexRecord) > mBufSize) {
1975	mHash->Update(mBuf, mBufPos);
1976
1977	rv = FlushBuffer();
1978	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1978); return rv; } } while (false);
1979	MOZ_ASSERT(mBufPos + sizeof(CacheIndexRecord) <= mBufSize)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mBufPos + sizeof(CacheIndexRecord) <= mBufSize)> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(mBufPos + sizeof(CacheIndexRecord) <= mBufSize))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("mBufPos + sizeof(CacheIndexRecord) <= mBufSize" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1979); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mBufPos + sizeof(CacheIndexRecord) <= mBufSize" ")"); do { ((volatile int)__null) = 1979; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1980	}
1981
1982	aEntry->WriteToBuf(mBuf + mBufPos);
1983	mBufPos += sizeof(CacheIndexRecord);
1984
1985	return NS_OK;
1986	}
1987
1988	nsresult WriteLogHelper::Finish() {
1989	nsresult rv;
1990
1991	mHash->Update(mBuf, mBufPos);
1992	if (mBufPos + sizeof(CacheHash::Hash32_t) > mBufSize) {
1993	rv = FlushBuffer();
1994	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1994); return rv; } } while (false);
1995	MOZ_ASSERT(mBufPos + sizeof(CacheHash::Hash32_t) <= mBufSize)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mBufPos + sizeof(CacheHash::Hash32_t) <= mBufSize )>::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(mBufPos + sizeof(CacheHash::Hash32_t) <= mBufSize ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mBufPos + sizeof(CacheHash::Hash32_t) <= mBufSize", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 1995); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mBufPos + sizeof(CacheHash::Hash32_t) <= mBufSize" ")"); do { ((volatile int)__null) = 1995; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
1996	}
1997
1998	NetworkEndian::writeUint32(mBuf + mBufPos, mHash->GetHash());
1999	mBufPos += sizeof(CacheHash::Hash32_t);
2000
2001	rv = FlushBuffer();
2002	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2002); return rv; } } while (false);
2003
2004	return NS_OK;
2005	}
2006
2007	nsresult WriteLogHelper::FlushBuffer() {
2008	if (CacheObserver::IsPastShutdownIOLag()) {
2009	LOG(("WriteLogHelper::FlushBuffer() - Interrupting writing journal."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "WriteLogHelper::FlushBuffer() - Interrupting writing journal." ); } } while (0);
2010	return NS_ERROR_FAILURE;
2011	}
2012
2013	int32_t bytesWritten = PR_Write(mFD, mBuf, mBufPos);
2014
2015	if (bytesWritten != mBufPos) {
2016	return NS_ERROR_FAILURE;
2017	}
2018
2019	mBufPos = 0;
2020	return NS_OK;
2021	}
2022
2023	nsresult CacheIndex::WriteLogToDisk() {
2024	LOG(("CacheIndex::WriteLogToDisk()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteLogToDisk()" ); } } while (0);
2025
2026	nsresult rv;
2027
2028	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2028); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 2028; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2029	MOZ_ASSERT(mState == SHUTDOWN)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == SHUTDOWN)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == SHUTDOWN))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == SHUTDOWN" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2029); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == SHUTDOWN" ")"); do { ((volatile int)__null) = 2029; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2030
2031	if (CacheObserver::IsPastShutdownIOLag()) {
2032	LOG(("CacheIndex::WriteLogToDisk() - Skipping writing journal."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::WriteLogToDisk() - Skipping writing journal." ); } } while (0);
2033	return NS_ERROR_FAILURE;
2034	}
2035
2036	RemoveFile(nsLiteralCString(TEMP_INDEX_NAME"index.tmp"));
2037
2038	nsCOMPtr<nsIFile> indexFile;
2039	rv = GetFile(nsLiteralCString(INDEX_NAME"index"), getter_AddRefs(indexFile));
2040	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2040); return rv; } } while (false);
2041
2042	nsCOMPtr<nsIFile> logFile;
2043	rv = GetFile(nsLiteralCString(JOURNAL_NAME"index.log"), getter_AddRefs(logFile));
2044	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2044); return rv; } } while (false);
2045
2046	mIndexStats.Log();
2047
2048	PRFileDesc* fd = nullptr;
2049	rv = logFile->OpenNSPRFileDesc(PR_RDWR0x04 \| PR_CREATE_FILE0x08 \| PR_TRUNCATE0x20, 0600,
2050	&fd);
2051	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2051); return rv; } } while (false);
2052
2053	WriteLogHelper wlh(fd);
2054	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
2055	CacheIndexEntry* entry = iter.Get();
2056	if (entry->IsRemoved() \|\| entry->IsDirty()) {
2057	rv = wlh.AddEntry(entry);
2058	if (NS_WARN_IF(NS_FAILED(rv))NS_warn_if_impl(((bool)(__builtin_expect(!!(NS_FAILED_impl(rv )), 0))), "NS_FAILED(rv)", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2058)) {
2059	return rv;
2060	}
2061	}
2062	}
2063
2064	rv = wlh.Finish();
2065	PR_Close(fd);
2066	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2066); return rv; } } while (false);
2067
2068	rv = indexFile->OpenNSPRFileDesc(PR_RDWR0x04, 0600, &fd);
2069	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2069); return rv; } } while (false);
2070
2071	// Seek to dirty flag in the index header and clear it.
2072	static_assert(2 * sizeof(uint32_t) == offsetof(CacheIndexHeader, mIsDirty)__builtin_offsetof(CacheIndexHeader, mIsDirty),
2073	"Unexpected offset of CacheIndexHeader::mIsDirty");
2074	int64_t offset = PR_Seek64(fd, 2 * sizeof(uint32_t), PR_SEEK_SET);
2075	if (offset == -1) {
2076	PR_Close(fd);
2077	return NS_ERROR_FAILURE;
2078	}
2079
2080	uint32_t isDirty = 0;
2081	int32_t bytesWritten = PR_Write(fd, &isDirty, sizeof(isDirty));
2082	PR_Close(fd);
2083	if (bytesWritten != sizeof(isDirty)) {
2084	return NS_ERROR_FAILURE;
2085	}
2086
2087	return NS_OK;
2088	}
2089
2090	void CacheIndex::ReadIndexFromDisk(const StaticMutexAutoLock& aProofOfLock) {
2091	sLock.AssertCurrentThreadOwns();
2092	LOG(("CacheIndex::ReadIndexFromDisk()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk()" ); } } while (0);
2093
2094	nsresult rv;
2095
2096	MOZ_ASSERT(mState == INITIAL)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == INITIAL)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == INITIAL))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == INITIAL" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2096); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == INITIAL" ")"); do { ((volatile int)__null) = 2096; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2097
2098	ChangeState(READING, aProofOfLock);
2099
2100	mIndexFileOpener = new FileOpenHelper(this);
2101	rv = CacheFileIOManager::OpenFile(
2102	nsLiteralCString(INDEX_NAME"index"),
2103	CacheFileIOManager::SPECIAL_FILE \| CacheFileIOManager::OPEN,
2104	mIndexFileOpener);
2105	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2106	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index"); } } while (0)
2107	("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index"); } } while (0)
2108	"failed [rv=0x%08" PRIx32 ", file=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index"); } } while (0)
2109	static_cast<uint32_t>(rv), INDEX_NAME))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index"); } } while (0);
2110	FinishRead(false, aProofOfLock);
2111	return;
2112	}
2113
2114	mJournalFileOpener = new FileOpenHelper(this);
2115	rv = CacheFileIOManager::OpenFile(
2116	nsLiteralCString(JOURNAL_NAME"index.log"),
2117	CacheFileIOManager::SPECIAL_FILE \| CacheFileIOManager::OPEN,
2118	mJournalFileOpener);
2119	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2120	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.log"); } } while (0)
2121	("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.log"); } } while (0)
2122	"failed [rv=0x%08" PRIx32 ", file=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.log"); } } while (0)
2123	static_cast<uint32_t>(rv), JOURNAL_NAME))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.log"); } } while (0);
2124	FinishRead(false, aProofOfLock);
2125	}
2126
2127	mTmpFileOpener = new FileOpenHelper(this);
2128	rv = CacheFileIOManager::OpenFile(
2129	nsLiteralCString(TEMP_INDEX_NAME"index.tmp"),
2130	CacheFileIOManager::SPECIAL_FILE \| CacheFileIOManager::OPEN,
2131	mTmpFileOpener);
2132	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2133	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.tmp"); } } while (0)
2134	("CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.tmp"); } } while (0)
2135	"failed [rv=0x%08" PRIx32 ", file=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.tmp"); } } while (0)
2136	static_cast<uint32_t>(rv), TEMP_INDEX_NAME))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReadIndexFromDisk() - CacheFileIOManager::OpenFile() " "failed [rv=0x%08" "x" ", file=%s]", static_cast<uint32_t >(rv), "index.tmp"); } } while (0);
2137	FinishRead(false, aProofOfLock);
2138	}
2139	}
2140
2141	void CacheIndex::StartReadingIndex(const StaticMutexAutoLock& aProofOfLock) {
2142	sLock.AssertCurrentThreadOwns();
2143	LOG(("CacheIndex::StartReadingIndex()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex()" ); } } while (0);
2144
2145	nsresult rv;
2146
2147	MOZ_ASSERT(mIndexHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mIndexHandle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mIndexHandle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2147); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexHandle" ")"); do { ((volatile int)__null) = 2147; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2148	MOZ_ASSERT(mState == READING)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == READING)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == READING))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == READING" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2148); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == READING" ")"); do { ((volatile int)__null) = 2148; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2149	MOZ_ASSERT(!mIndexOnDiskIsValid)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mIndexOnDiskIsValid)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mIndexOnDiskIsValid))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("!mIndexOnDiskIsValid" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2149); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mIndexOnDiskIsValid" ")"); do { ((volatile int)__null) = 2149; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2150	MOZ_ASSERT(!mDontMarkIndexClean)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mDontMarkIndexClean)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mDontMarkIndexClean))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("!mDontMarkIndexClean" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2150); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mDontMarkIndexClean" ")"); do { ((volatile int)__null) = 2150; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2151	MOZ_ASSERT(!mJournalReadSuccessfully)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mJournalReadSuccessfully)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mJournalReadSuccessfully))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mJournalReadSuccessfully" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2151); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mJournalReadSuccessfully" ")"); do { ((volatile int)__null) = 2151; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2152	MOZ_ASSERT(mIndexHandle->FileSize() >= 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexHandle->FileSize() >= 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mIndexHandle->FileSize() >= 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("mIndexHandle->FileSize() >= 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2152); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexHandle->FileSize() >= 0" ")"); do { ((volatile int)__null) = 2152; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2153	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2153); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 2153; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2154
2155	int64_t entriesSize = mIndexHandle->FileSize() - sizeof(CacheIndexHeader) -
2156	sizeof(CacheHash::Hash32_t);
2157
2158	if (entriesSize < 0 \|\| entriesSize % sizeof(CacheIndexRecord)) {
2159	LOG(("CacheIndex::StartReadingIndex() - Index is corrupted"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex() - Index is corrupted" ); } } while (0);
2160	FinishRead(false, aProofOfLock);
2161	return;
2162	}
2163
2164	AllocBuffer();
2165	mSkipEntries = 0;
2166	mRWHash = new CacheHash();
2167
2168	mRWBufPos =
2169	std::min(mRWBufSize, static_cast<uint32_t>(mIndexHandle->FileSize()));
2170
2171	rv = CacheFileIOManager::Read(mIndexHandle, 0, mRWBuf, mRWBufPos, this);
2172	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2173	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2174	("CacheIndex::StartReadingIndex() - CacheFileIOManager::Read() failed "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2175	"synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2176	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingIndex() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0);
2177	FinishRead(false, aProofOfLock);
2178	} else {
2179	mRWPending = true;
2180	}
2181	}
2182
2183	void CacheIndex::ParseRecords(const StaticMutexAutoLock& aProofOfLock) {
2184	sLock.AssertCurrentThreadOwns();
2185	LOG(("CacheIndex::ParseRecords()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords()" ); } } while (0);
2186
2187	nsresult rv;
2188
2189	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2189); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 2189; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2190
2191	uint32_t entryCnt = (mIndexHandle->FileSize() - sizeof(CacheIndexHeader) -
2192	sizeof(CacheHash::Hash32_t)) /
2193	sizeof(CacheIndexRecord);
2194	uint32_t pos = 0;
2195
2196	if (!mSkipEntries) {
2197	if (NetworkEndian::readUint32(mRWBuf + pos) != kIndexVersion0x0000000A) {
2198	FinishRead(false, aProofOfLock);
2199	return;
2200	}
2201	pos += sizeof(uint32_t);
2202
2203	mIndexTimeStamp = NetworkEndian::readUint32(mRWBuf + pos);
2204	pos += sizeof(uint32_t);
2205
2206	if (NetworkEndian::readUint32(mRWBuf + pos)) {
2207	if (mJournalHandle) {
2208	CacheFileIOManager::DoomFile(mJournalHandle, nullptr);
2209	mJournalHandle = nullptr;
2210	}
2211	} else {
2212	uint32_t* isDirty =
2213	reinterpret_cast<uint32_t*>(moz_xmalloc(sizeof(uint32_t)));
2214	NetworkEndian::writeUint32(isDirty, 1);
2215
2216	// Mark index dirty. The buffer will be freed by CacheFileIOManager.
2217	CacheFileIOManager::WriteWithoutCallback(
2218	mIndexHandle, 2 * sizeof(uint32_t), reinterpret_cast<char*>(isDirty),
2219	sizeof(uint32_t), true, false);
2220	}
2221	pos += sizeof(uint32_t);
2222
2223	uint64_t dataWritten = NetworkEndian::readUint32(mRWBuf + pos);
2224	pos += sizeof(uint32_t);
2225	dataWritten <<= 10;
2226	mTotalBytesWritten += dataWritten;
2227	}
2228
2229	uint32_t hashOffset = pos;
2230
2231	while (pos + sizeof(CacheIndexRecord) <= mRWBufPos &&
2232	mSkipEntries != entryCnt) {
2233	CacheIndexRecord* rec = reinterpret_cast<CacheIndexRecord*>(mRWBuf + pos);
2234	CacheIndexEntry tmpEntry(&rec->mHash);
2235	tmpEntry.ReadFromBuf(mRWBuf + pos);
2236
2237	if (tmpEntry.IsDirty() \|\| !tmpEntry.IsInitialized() \|\|
2238	tmpEntry.IsFileEmpty() \|\| tmpEntry.IsFresh() \|\| tmpEntry.IsRemoved()) {
2239	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0)
2240	("CacheIndex::ParseRecords() - Invalid entry found in index, removing"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0)
2241	" whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0)
2242	"removed=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0)
2243	tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(),do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0)
2244	tmpEntry.IsFresh(), tmpEntry.IsRemoved()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Invalid entry found in index, removing" " whole index [dirty=%d, initialized=%d, fileEmpty=%d, fresh=%d, " "removed=%d]", tmpEntry.IsDirty(), tmpEntry.IsInitialized(), tmpEntry.IsFileEmpty(), tmpEntry.IsFresh(), tmpEntry.IsRemoved ()); } } while (0);
2245	FinishRead(false, aProofOfLock);
2246	return;
2247	}
2248
2249	CacheIndexEntryAutoManage emng(tmpEntry.Hash(), this, aProofOfLock);
2250
2251	CacheIndexEntry* entry = mIndex.PutEntry(*tmpEntry.Hash());
2252	*entry = tmpEntry;
2253
2254	pos += sizeof(CacheIndexRecord);
2255	mSkipEntries++;
2256	}
2257
2258	mRWHash->Update(mRWBuf + hashOffset, pos - hashOffset);
2259
2260	if (pos != mRWBufPos) {
2261	memmove(mRWBuf, mRWBuf + pos, mRWBufPos - pos);
2262	}
2263
2264	mRWBufPos -= pos;
2265	pos = 0;
2266
2267	int64_t fileOffset = sizeof(CacheIndexHeader) +
2268	mSkipEntries * sizeof(CacheIndexRecord) + mRWBufPos;
2269
2270	MOZ_ASSERT(fileOffset <= mIndexHandle->FileSize())do { static_assert( mozilla::detail::AssertionConditionType< decltype(fileOffset <= mIndexHandle->FileSize())>::isValid , "invalid assertion condition"); if ((__builtin_expect(!!(!( !!(fileOffset <= mIndexHandle->FileSize()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("fileOffset <= mIndexHandle->FileSize()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2270); AnnotateMozCrashReason("MOZ_ASSERT" "(" "fileOffset <= mIndexHandle->FileSize()" ")"); do { ((volatile int)__null) = 2270; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2271	if (fileOffset == mIndexHandle->FileSize()) {
2272	uint32_t expectedHash = NetworkEndian::readUint32(mRWBuf);
2273	if (mRWHash->GetHash() != expectedHash) {
2274	LOG(("CacheIndex::ParseRecords() - Hash mismatch, [is %x, should be %x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Hash mismatch, [is %x, should be %x]" , mRWHash->GetHash(), expectedHash); } } while (0)
2275	mRWHash->GetHash(), expectedHash))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - Hash mismatch, [is %x, should be %x]" , mRWHash->GetHash(), expectedHash); } } while (0);
2276	FinishRead(false, aProofOfLock);
2277	return;
2278	}
2279
2280	mIndexOnDiskIsValid = true;
2281	mJournalReadSuccessfully = false;
2282
2283	if (mJournalHandle) {
2284	StartReadingJournal(aProofOfLock);
2285	} else {
2286	FinishRead(false, aProofOfLock);
2287	}
2288
2289	return;
2290	}
2291
2292	pos = mRWBufPos;
2293	uint32_t toRead =
2294	std::min(mRWBufSize - pos,
2295	static_cast<uint32_t>(mIndexHandle->FileSize() - fileOffset));
2296	mRWBufPos = pos + toRead;
2297
2298	rv = CacheFileIOManager::Read(mIndexHandle, fileOffset, mRWBuf + pos, toRead,
2299	this);
2300	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2301	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2302	("CacheIndex::ParseRecords() - CacheFileIOManager::Read() failed "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2303	"synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2304	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseRecords() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0);
2305	FinishRead(false, aProofOfLock);
2306	return;
2307	}
2308	mRWPending = true;
2309	}
2310
2311	void CacheIndex::StartReadingJournal(const StaticMutexAutoLock& aProofOfLock) {
2312	sLock.AssertCurrentThreadOwns();
2313	LOG(("CacheIndex::StartReadingJournal()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal()" ); } } while (0);
2314
2315	nsresult rv;
2316
2317	MOZ_ASSERT(mJournalHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mJournalHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mJournalHandle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mJournalHandle" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2317); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mJournalHandle" ")"); do { ((volatile int)__null) = 2317; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2318	MOZ_ASSERT(mIndexOnDiskIsValid)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexOnDiskIsValid)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mIndexOnDiskIsValid))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mIndexOnDiskIsValid" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2318); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexOnDiskIsValid" ")"); do { ((volatile int)__null) = 2318; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2319	MOZ_ASSERT(mTmpJournal.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mTmpJournal.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mTmpJournal.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mTmpJournal.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2319); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTmpJournal.Count() == 0" ")"); do { ((volatile int)__null) = 2319; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2320	MOZ_ASSERT(mJournalHandle->FileSize() >= 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mJournalHandle->FileSize() >= 0)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(! !(mJournalHandle->FileSize() >= 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mJournalHandle->FileSize() >= 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2320); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mJournalHandle->FileSize() >= 0" ")"); do { ((volatile int)__null) = 2320; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2321	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2321); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 2321; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2322
2323	int64_t entriesSize =
2324	mJournalHandle->FileSize() - sizeof(CacheHash::Hash32_t);
2325
2326	if (entriesSize < 0 \|\| entriesSize % sizeof(CacheIndexRecord)) {
2327	LOG(("CacheIndex::StartReadingJournal() - Journal is corrupted"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal() - Journal is corrupted" ); } } while (0);
2328	FinishRead(false, aProofOfLock);
2329	return;
2330	}
2331
2332	mSkipEntries = 0;
2333	mRWHash = new CacheHash();
2334
2335	mRWBufPos =
2336	std::min(mRWBufSize, static_cast<uint32_t>(mJournalHandle->FileSize()));
2337
2338	rv = CacheFileIOManager::Read(mJournalHandle, 0, mRWBuf, mRWBufPos, this);
2339	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2340	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal() - CacheFileIOManager::Read() failed" " synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2341	("CacheIndex::StartReadingJournal() - CacheFileIOManager::Read() failed"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal() - CacheFileIOManager::Read() failed" " synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2342	" synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal() - CacheFileIOManager::Read() failed" " synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2343	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartReadingJournal() - CacheFileIOManager::Read() failed" " synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0);
2344	FinishRead(false, aProofOfLock);
2345	} else {
2346	mRWPending = true;
2347	}
2348	}
2349
2350	void CacheIndex::ParseJournal(const StaticMutexAutoLock& aProofOfLock) {
2351	sLock.AssertCurrentThreadOwns();
2352	LOG(("CacheIndex::ParseJournal()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal()" ); } } while (0);
2353
2354	nsresult rv;
2355
2356	MOZ_ASSERT(!mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2356); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending" ")"); do { ((volatile int)__null) = 2356; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2357
2358	uint32_t entryCnt =
2359	(mJournalHandle->FileSize() - sizeof(CacheHash::Hash32_t)) /
2360	sizeof(CacheIndexRecord);
2361
2362	uint32_t pos = 0;
2363
2364	while (pos + sizeof(CacheIndexRecord) <= mRWBufPos &&
2365	mSkipEntries != entryCnt) {
2366	CacheIndexEntry tmpEntry(reinterpret_cast<SHA1Sum::Hash*>(mRWBuf + pos));
2367	tmpEntry.ReadFromBuf(mRWBuf + pos);
2368
2369	CacheIndexEntry* entry = mTmpJournal.PutEntry(*tmpEntry.Hash());
2370	*entry = tmpEntry;
2371
2372	if (entry->IsDirty() \|\| entry->IsFresh()) {
2373	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Invalid entry found in journal, " "ignoring whole journal [dirty=%d, fresh=%d]", entry->IsDirty (), entry->IsFresh()); } } while (0)
2374	("CacheIndex::ParseJournal() - Invalid entry found in journal, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Invalid entry found in journal, " "ignoring whole journal [dirty=%d, fresh=%d]", entry->IsDirty (), entry->IsFresh()); } } while (0)
2375	"ignoring whole journal [dirty=%d, fresh=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Invalid entry found in journal, " "ignoring whole journal [dirty=%d, fresh=%d]", entry->IsDirty (), entry->IsFresh()); } } while (0)
2376	entry->IsDirty(), entry->IsFresh()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Invalid entry found in journal, " "ignoring whole journal [dirty=%d, fresh=%d]", entry->IsDirty (), entry->IsFresh()); } } while (0);
2377	FinishRead(false, aProofOfLock);
2378	return;
2379	}
2380
2381	pos += sizeof(CacheIndexRecord);
2382	mSkipEntries++;
2383	}
2384
2385	mRWHash->Update(mRWBuf, pos);
2386
2387	if (pos != mRWBufPos) {
2388	memmove(mRWBuf, mRWBuf + pos, mRWBufPos - pos);
2389	}
2390
2391	mRWBufPos -= pos;
2392	pos = 0;
	Value stored to 'pos' is never read
2393
2394	int64_t fileOffset = mSkipEntries * sizeof(CacheIndexRecord) + mRWBufPos;
2395
2396	MOZ_ASSERT(fileOffset <= mJournalHandle->FileSize())do { static_assert( mozilla::detail::AssertionConditionType< decltype(fileOffset <= mJournalHandle->FileSize())>:: isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(fileOffset <= mJournalHandle->FileSize()))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("fileOffset <= mJournalHandle->FileSize()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2396); AnnotateMozCrashReason("MOZ_ASSERT" "(" "fileOffset <= mJournalHandle->FileSize()" ")"); do { ((volatile int)__null) = 2396; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2397	if (fileOffset == mJournalHandle->FileSize()) {
2398	uint32_t expectedHash = NetworkEndian::readUint32(mRWBuf);
2399	if (mRWHash->GetHash() != expectedHash) {
2400	LOG(("CacheIndex::ParseJournal() - Hash mismatch, [is %x, should be %x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Hash mismatch, [is %x, should be %x]" , mRWHash->GetHash(), expectedHash); } } while (0)
2401	mRWHash->GetHash(), expectedHash))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - Hash mismatch, [is %x, should be %x]" , mRWHash->GetHash(), expectedHash); } } while (0);
2402	FinishRead(false, aProofOfLock);
2403	return;
2404	}
2405
2406	mJournalReadSuccessfully = true;
2407	FinishRead(true, aProofOfLock);
2408	return;
2409	}
2410
2411	pos = mRWBufPos;
2412	uint32_t toRead =
2413	std::min(mRWBufSize - pos,
2414	static_cast<uint32_t>(mJournalHandle->FileSize() - fileOffset));
2415	mRWBufPos = pos + toRead;
2416
2417	rv = CacheFileIOManager::Read(mJournalHandle, fileOffset, mRWBuf + pos,
2418	toRead, this);
2419	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2420	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2421	("CacheIndex::ParseJournal() - CacheFileIOManager::Read() failed "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2422	"synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0)
2423	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ParseJournal() - CacheFileIOManager::Read() failed " "synchronously [rv=0x%08" "x" "]", static_cast<uint32_t> (rv)); } } while (0);
2424	FinishRead(false, aProofOfLock);
2425	return;
2426	}
2427	mRWPending = true;
2428	}
2429
2430	void CacheIndex::MergeJournal(const StaticMutexAutoLock& aProofOfLock) {
2431	sLock.AssertCurrentThreadOwns();
2432	LOG(("CacheIndex::MergeJournal()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::MergeJournal()" ); } } while (0);
2433
2434	for (auto iter = mTmpJournal.Iter(); !iter.Done(); iter.Next()) {
2435	CacheIndexEntry* entry = iter.Get();
2436
2437	LOG(("CacheIndex::MergeJournal() [hash=%08x%08x%08x%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::MergeJournal() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(entry-> Hash()))[0]), PR_htonl((reinterpret_cast<const uint32_t> (entry->Hash()))[1]), PR_htonl((reinterpret_cast<const uint32_t >(entry->Hash()))[2]), PR_htonl((reinterpret_cast<const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 )
2438	LOGSHA1(entry->Hash())))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::MergeJournal() [hash=%08x%08x%08x%08x%08x]" , PR_htonl((reinterpret_cast<const uint32_t>(entry-> Hash()))[0]), PR_htonl((reinterpret_cast<const uint32_t> (entry->Hash()))[1]), PR_htonl((reinterpret_cast<const uint32_t >(entry->Hash()))[2]), PR_htonl((reinterpret_cast<const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 );
2439
2440	CacheIndexEntry* entry2 = mIndex.GetEntry(*entry->Hash());
2441	{
2442	CacheIndexEntryAutoManage emng(entry->Hash(), this, aProofOfLock);
2443	if (entry->IsRemoved()) {
2444	if (entry2) {
2445	entry2->MarkRemoved();
2446	entry2->MarkDirty();
2447	}
2448	} else {
2449	if (!entry2) {
2450	entry2 = mIndex.PutEntry(*entry->Hash());
2451	}
2452
2453	entry2 = entry;
2454	entry2->MarkDirty();
2455	}
2456	}
2457	iter.Remove();
2458	}
2459
2460	MOZ_ASSERT(mTmpJournal.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mTmpJournal.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mTmpJournal.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mTmpJournal.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2460); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTmpJournal.Count() == 0" ")"); do { ((volatile int)__null) = 2460; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2461	}
2462
2463	void CacheIndex::EnsureNoFreshEntry() {
2464	#ifdef DEBUG_STATS1
2465	CacheIndexStats debugStats;
2466	debugStats.DisableLogging();
2467	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
2468	debugStats.BeforeChange(nullptr);
2469	debugStats.AfterChange(iter.Get());
2470	}
2471	MOZ_ASSERT(debugStats.Fresh() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(debugStats.Fresh() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(debugStats.Fresh() == 0))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("debugStats.Fresh() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2471); AnnotateMozCrashReason("MOZ_ASSERT" "(" "debugStats.Fresh() == 0" ")"); do { ((volatile int)__null) = 2471; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2472	#endif
2473	}
2474
2475	void CacheIndex::EnsureCorrectStats() {
2476	#ifdef DEBUG_STATS1
2477	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2477); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 2477; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2478	CacheIndexStats debugStats;
2479	debugStats.DisableLogging();
2480	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
2481	debugStats.BeforeChange(nullptr);
2482	debugStats.AfterChange(iter.Get());
2483	}
2484	MOZ_ASSERT(debugStats == mIndexStats)do { static_assert( mozilla::detail::AssertionConditionType< decltype(debugStats == mIndexStats)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(debugStats == mIndexStats))) , 0))) { do { } while (false); MOZ_ReportAssertionFailure("debugStats == mIndexStats" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2484); AnnotateMozCrashReason("MOZ_ASSERT" "(" "debugStats == mIndexStats" ")"); do { ((volatile int)__null) = 2484; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2485	#endif
2486	}
2487
2488	void CacheIndex::FinishRead(bool aSucceeded,
2489	const StaticMutexAutoLock& aProofOfLock) {
2490	sLock.AssertCurrentThreadOwns();
2491	LOG(("CacheIndex::FinishRead() [succeeded=%d]", aSucceeded))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishRead() [succeeded=%d]" , aSucceeded); } } while (0);
2492
2493	MOZ_ASSERT((!aSucceeded && mState == SHUTDOWN) \|\| mState == READING)do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && mState == SHUTDOWN) \|\| mState == READING)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!((!aSucceeded && mState == SHUTDOWN) \|\| mState == READING))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("(!aSucceeded && mState == SHUTDOWN) \|\| mState == READING" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2493); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && mState == SHUTDOWN) \|\| mState == READING" ")"); do { ((volatile int)__null) = 2493; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2494
2495	MOZ_ASSERT(do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2496	// -> rebuilddo { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2497	(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2498	// -> updatedo { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2499	(!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2500	// -> readydo { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
2501	(aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))do { static_assert( mozilla::detail::AssertionConditionType< decltype((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully))> ::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!((!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2501); AnnotateMozCrashReason("MOZ_ASSERT" "(" "(!aSucceeded && !mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (!aSucceeded && mIndexOnDiskIsValid && !mJournalReadSuccessfully) \|\| (aSucceeded && mIndexOnDiskIsValid && mJournalReadSuccessfully)" ")"); do { ((volatile int)__null) = 2501; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2502
2503	// If there is read operation pending we must be cancelling reading of the
2504	// index when shutting down or removing the whole index.
2505	MOZ_ASSERT(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll)))do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll)))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))))), 0))) { do { } while (false ); MOZ_ReportAssertionFailure("!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2505); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mRWPending \|\| (!aSucceeded && (mShuttingDown \|\| mRemovingAll))" ")"); do { ((volatile int)__null) = 2505; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2506
2507	if (mState == SHUTDOWN) {
2508	RemoveFile(nsLiteralCString(TEMP_INDEX_NAME"index.tmp"));
2509	RemoveFile(nsLiteralCString(JOURNAL_NAME"index.log"));
2510	} else {
2511	if (mIndexHandle && !mIndexOnDiskIsValid) {
2512	CacheFileIOManager::DoomFile(mIndexHandle, nullptr);
2513	}
2514
2515	if (mJournalHandle) {
2516	CacheFileIOManager::DoomFile(mJournalHandle, nullptr);
2517	}
2518	}
2519
2520	if (mIndexFileOpener) {
2521	mIndexFileOpener->Cancel();
2522	mIndexFileOpener = nullptr;
2523	}
2524	if (mJournalFileOpener) {
2525	mJournalFileOpener->Cancel();
2526	mJournalFileOpener = nullptr;
2527	}
2528	if (mTmpFileOpener) {
2529	mTmpFileOpener->Cancel();
2530	mTmpFileOpener = nullptr;
2531	}
2532
2533	mIndexHandle = nullptr;
2534	mJournalHandle = nullptr;
2535	mRWHash = nullptr;
2536	ReleaseBuffer();
2537
2538	if (mState == SHUTDOWN) {
2539	return;
2540	}
2541
2542	if (!mIndexOnDiskIsValid) {
2543	MOZ_ASSERT(mTmpJournal.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mTmpJournal.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mTmpJournal.Count() == 0))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mTmpJournal.Count() == 0" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2543); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mTmpJournal.Count() == 0" ")"); do { ((volatile int)__null) = 2543; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2544	EnsureNoFreshEntry();
2545	ProcessPendingOperations(aProofOfLock);
2546	// Remove all entries that we haven't seen during this session
2547	RemoveNonFreshEntries(aProofOfLock);
2548	StartUpdatingIndex(true, aProofOfLock);
2549	return;
2550	}
2551
2552	if (!mJournalReadSuccessfully) {
2553	mTmpJournal.Clear();
2554	EnsureNoFreshEntry();
2555	ProcessPendingOperations(aProofOfLock);
2556	StartUpdatingIndex(false, aProofOfLock);
2557	return;
2558	}
2559
2560	MergeJournal(aProofOfLock);
2561	EnsureNoFreshEntry();
2562	ProcessPendingOperations(aProofOfLock);
2563	mIndexStats.Log();
2564
2565	ChangeState(READY, aProofOfLock);
2566	mLastDumpTime = TimeStamp::NowLoRes(); // Do not dump new index immediately
2567	}
2568
2569	// static
2570	void CacheIndex::DelayedUpdate(nsITimer* aTimer, void* aClosure) {
2571	LOG(("CacheIndex::DelayedUpdate()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::DelayedUpdate()" ); } } while (0);
2572
2573	StaticMutexAutoLock lock(sLock);
2574	RefPtr<CacheIndex> index = gInstance;
2575
2576	if (!index) {
2577	return;
2578	}
2579
2580	index->DelayedUpdateLocked(lock);
2581	}
2582
2583	// static
2584	void CacheIndex::DelayedUpdateLocked(const StaticMutexAutoLock& aProofOfLock) {
2585	sLock.AssertCurrentThreadOwns();
2586	LOG(("CacheIndex::DelayedUpdateLocked()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::DelayedUpdateLocked()" ); } } while (0);
2587
2588	nsresult rv;
2589
2590	mUpdateTimer = nullptr;
2591
2592	if (!IsIndexUsable()) {
2593	return;
2594	}
2595
2596	if (mState == READY && mShuttingDown) {
2597	return;
2598	}
2599
2600	// mUpdateEventPending must be false here since StartUpdatingIndex() won't
2601	// schedule timer if it is true.
2602	MOZ_ASSERT(!mUpdateEventPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mUpdateEventPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mUpdateEventPending))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("!mUpdateEventPending" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2602); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mUpdateEventPending" ")"); do { ((volatile int)__null) = 2602; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2603	if (mState != BUILDING && mState != UPDATING) {
2604	LOG(("CacheIndex::DelayedUpdateLocked() - Update was canceled"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::DelayedUpdateLocked() - Update was canceled" ); } } while (0);
2605	return;
2606	}
2607
2608	// We need to redispatch to run with lower priority
2609	RefPtr<CacheIOThread> ioThread = CacheFileIOManager::IOThread();
2610	MOZ_ASSERT(ioThread)do { static_assert( mozilla::detail::AssertionConditionType< decltype(ioThread)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(ioThread))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("ioThread", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2610); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ioThread" ")" ); do { ((volatile int)__null) = 2610; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2611
2612	mUpdateEventPending = true;
2613	rv = ioThread->Dispatch(this, CacheIOThread::INDEX);
2614	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2615	mUpdateEventPending = false;
2616	NS_WARNING("CacheIndex::DelayedUpdateLocked() - Can't dispatch event")NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::DelayedUpdateLocked() - Can't dispatch event" , nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2616);
2617	LOG(("CacheIndex::DelayedUpdate() - Can't dispatch event"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::DelayedUpdate() - Can't dispatch event" ); } } while (0);
2618	FinishUpdate(false, aProofOfLock);
2619	}
2620	}
2621
2622	nsresult CacheIndex::ScheduleUpdateTimer(uint32_t aDelay) {
2623	LOG(("CacheIndex::ScheduleUpdateTimer() [delay=%u]", aDelay))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ScheduleUpdateTimer() [delay=%u]" , aDelay); } } while (0);
2624
2625	MOZ_ASSERT(!mUpdateTimer)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mUpdateTimer)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mUpdateTimer))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mUpdateTimer", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2625); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mUpdateTimer" ")"); do { ((volatile int)__null) = 2625; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2626
2627	nsCOMPtr<nsIEventTarget> ioTarget = CacheFileIOManager::IOTarget();
2628	MOZ_ASSERT(ioTarget)do { static_assert( mozilla::detail::AssertionConditionType< decltype(ioTarget)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(ioTarget))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("ioTarget", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2628); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ioTarget" ")" ); do { ((volatile int)__null) = 2628; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2629
2630	return NS_NewTimerWithFuncCallback(
2631	getter_AddRefs(mUpdateTimer), CacheIndex::DelayedUpdate, nullptr, aDelay,
2632	nsITimer::TYPE_ONE_SHOT, "net::CacheIndex::ScheduleUpdateTimer",
2633	ioTarget);
2634	}
2635
2636	nsresult CacheIndex::SetupDirectoryEnumerator() {
2637	MOZ_ASSERT(!NS_IsMainThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(!NS_IsMainThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!NS_IsMainThread()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!NS_IsMainThread()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2637); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!NS_IsMainThread()" ")"); do { ((volatile int)__null) = 2637; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2638	MOZ_ASSERT(!mDirEnumerator)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mDirEnumerator)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mDirEnumerator))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mDirEnumerator" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2638); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mDirEnumerator" ")"); do { ((volatile int)__null) = 2638; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2639
2640	nsresult rv;
2641	nsCOMPtr<nsIFile> file;
2642
2643	rv = mCacheDirectory->Clone(getter_AddRefs(file));
2644	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2644); return rv; } } while (false);
2645
2646	rv = file->AppendNative(nsLiteralCString(ENTRIES_DIR"entries"));
2647	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2647); return rv; } } while (false);
2648
2649	bool exists;
2650	rv = file->Exists(&exists);
2651	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2651); return rv; } } while (false);
2652
2653	if (!exists) {
2654	NS_WARNING(NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::SetupDirectoryEnumerator() - Entries directory " "doesn't exist!", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2656)
2655	"CacheIndex::SetupDirectoryEnumerator() - Entries directory "NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::SetupDirectoryEnumerator() - Entries directory " "doesn't exist!", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2656)
2656	"doesn't exist!")NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::SetupDirectoryEnumerator() - Entries directory " "doesn't exist!", nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2656);
2657	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::SetupDirectoryEnumerator() - Entries directory doesn't " "exist!"); } } while (0)
2658	("CacheIndex::SetupDirectoryEnumerator() - Entries directory doesn't "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::SetupDirectoryEnumerator() - Entries directory doesn't " "exist!"); } } while (0)
2659	"exist!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::SetupDirectoryEnumerator() - Entries directory doesn't " "exist!"); } } while (0);
2660	return NS_ERROR_UNEXPECTED;
2661	}
2662
2663	// Do not do IO under the lock.
2664	nsCOMPtr<nsIDirectoryEnumerator> dirEnumerator;
2665	{
2666	StaticMutexAutoUnlock unlock(sLock);
2667	rv = file->GetDirectoryEntries(getter_AddRefs(dirEnumerator));
2668	}
2669	mDirEnumerator = dirEnumerator.forget();
2670	NS_ENSURE_SUCCESS(rv, rv)do { nsresult __rv = rv; if (((bool)(__builtin_expect(!!(NS_FAILED_impl (__rv)), 0)))) { const char* name = mozilla::GetStaticErrorName (__rv); mozilla::SmprintfPointer msg = mozilla::Smprintf( "NS_ENSURE_SUCCESS(%s, %s) failed with " "result 0x%" "X" "%s%s%s", "rv", "rv", static_cast<uint32_t >(__rv), name ? " (" : "", name ? name : "", name ? ")" : "" ); NS_DebugBreak(NS_DEBUG_WARNING, msg.get(), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2670); return rv; } } while (false);
2671
2672	return NS_OK;
2673	}
2674
2675	nsresult CacheIndex::InitEntryFromDiskData(CacheIndexEntry* aEntry,
2676	CacheFileMetadata* aMetaData,
2677	int64_t aFileSize) {
2678	nsresult rv;
2679
2680	aEntry->InitNew();
2681	aEntry->MarkDirty();
2682	aEntry->MarkFresh();
2683
2684	aEntry->Init(GetOriginAttrsHash(aMetaData->OriginAttributes()),
2685	aMetaData->IsAnonymous(), aMetaData->Pinned());
2686
2687	aEntry->SetFrecency(aMetaData->GetFrecency());
2688
2689	const char* altData = aMetaData->GetElement(CacheFileUtils::kAltDataKey);
2690	bool hasAltData = altData != nullptr;
2691	if (hasAltData && NS_FAILED(CacheFileUtils::ParseAlternativeDataInfo(((bool)(__builtin_expect(!!(NS_FAILED_impl(CacheFileUtils::ParseAlternativeDataInfo ( altData, nullptr, nullptr))), 0)))
2692	altData, nullptr, nullptr))((bool)(__builtin_expect(!!(NS_FAILED_impl(CacheFileUtils::ParseAlternativeDataInfo ( altData, nullptr, nullptr))), 0)))) {
2693	return NS_ERROR_FAILURE;
2694	}
2695	aEntry->SetHasAltData(hasAltData);
2696
2697	static auto toUint16 = [](const char* aUint16String) -> uint16_t {
2698	if (!aUint16String) {
2699	return kIndexTimeNotAvailable;
2700	}
2701	nsresult rv;
2702	uint64_t n64 = nsDependentCString(aUint16String).ToInteger64(&rv);
2703	MOZ_ASSERT(NS_SUCCEEDED(rv))do { static_assert( mozilla::detail::AssertionConditionType< decltype(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1) )))>::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1) ))))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2703); AnnotateMozCrashReason("MOZ_ASSERT" "(" "((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))" ")"); do { ((volatile int)__null) = 2703; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2704	return n64 <= kIndexTimeOutOfBound ? n64 : kIndexTimeOutOfBound;
2705	};
2706
2707	aEntry->SetOnStartTime(
2708	toUint16(aMetaData->GetElement("net-response-time-onstart")));
2709	aEntry->SetOnStopTime(
2710	toUint16(aMetaData->GetElement("net-response-time-onstop")));
2711
2712	const char* contentTypeStr = aMetaData->GetElement("ctid");
2713	uint8_t contentType = nsICacheEntry::CONTENT_TYPE_UNKNOWN;
2714	if (contentTypeStr) {
2715	int64_t n64 = nsDependentCString(contentTypeStr).ToInteger64(&rv);
2716	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0))) \|\| n64 < nsICacheEntry::CONTENT_TYPE_UNKNOWN \|\|
2717	n64 >= nsICacheEntry::CONTENT_TYPE_LAST) {
2718	n64 = nsICacheEntry::CONTENT_TYPE_UNKNOWN;
2719	}
2720	contentType = n64;
2721	}
2722	aEntry->SetContentType(contentType);
2723
2724	aEntry->SetFileSize(static_cast<uint32_t>(std::min(
2725	static_cast<int64_t>(PR_UINT32_MAX4294967295U), (aFileSize + 0x3FF) >> 10)));
2726	return NS_OK;
2727	}
2728
2729	bool CacheIndex::IsUpdatePending() {
2730	sLock.AssertCurrentThreadOwns();
2731
2732	return mUpdateTimer \|\| mUpdateEventPending;
2733	}
2734
2735	void CacheIndex::BuildIndex(const StaticMutexAutoLock& aProofOfLock) {
2736	sLock.AssertCurrentThreadOwns();
2737	LOG(("CacheIndex::BuildIndex()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex()" ); } } while (0);
2738
2739	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2739); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 2739; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2740
2741	nsresult rv;
2742
2743	if (!mDirEnumerator) {
2744	rv = SetupDirectoryEnumerator();
2745	if (mState == SHUTDOWN) {
2746	// The index was shut down while we released the lock. FinishUpdate() was
2747	// already called from Shutdown(), so just simply return here.
2748	return;
2749	}
2750
2751	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2752	FinishUpdate(false, aProofOfLock);
2753	return;
2754	}
2755	}
2756
2757	while (true) {
2758	if (CacheIOThread::YieldAndRerun()) {
2759	LOG((do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Breaking loop for higher level events." ); } } while (0)
2760	"CacheIndex::BuildIndex() - Breaking loop for higher level events."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Breaking loop for higher level events." ); } } while (0);
2761	mUpdateEventPending = true;
2762	return;
2763	}
2764
2765	bool fileExists = false;
2766	nsCOMPtr<nsIFile> file;
2767	{
2768	// Do not do IO under the lock.
2769	nsCOMPtr<nsIDirectoryEnumerator> dirEnumerator(mDirEnumerator);
2770	sLock.AssertCurrentThreadOwns();
2771	StaticMutexAutoUnlock unlock(sLock);
2772	rv = dirEnumerator->GetNextFile(getter_AddRefs(file));
2773
2774	if (file) {
2775	file->Exists(&fileExists);
2776	}
2777	}
2778	if (mState == SHUTDOWN) {
2779	return;
2780	}
2781	if (!file) {
2782	FinishUpdate(NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))), aProofOfLock);
2783	return;
2784	}
2785
2786	nsAutoCString leaf;
2787	rv = file->GetNativeLeafName(leaf);
2788	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2789	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0)
2790	("CacheIndex::BuildIndex() - GetNativeLeafName() failed! Skipping "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0)
2791	"file."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0);
2792	mDontMarkIndexClean = true;
2793	continue;
2794	}
2795
2796	if (!fileExists) {
2797	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
2798	("CacheIndex::BuildIndex() - File returned by the iterator was "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
2799	"removed in the meantime [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
2800	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0);
2801	continue;
2802	}
2803
2804	SHA1Sum::Hash hash;
2805	rv = CacheFileIOManager::StrToHash(leaf, &hash);
2806	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2807	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
2808	("CacheIndex::BuildIndex() - Filename is not a hash, removing file. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
2809	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
2810	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0);
2811	file->Remove(false);
2812	continue;
2813	}
2814
2815	CacheIndexEntry* entry = mIndex.GetEntry(hash);
2816	if (entry && entry->IsRemoved()) {
2817	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
2818	("CacheIndex::BuildIndex() - Found file that should not exist. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
2819	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
2820	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0);
2821	entry->Log();
2822	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2822); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 2822; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2823	entry = nullptr;
2824	}
2825
2826	#ifdef DEBUG1
2827	RefPtr<CacheFileHandle> handle;
2828	CacheFileIOManager::gInstance->mHandles.GetHandle(&hash,
2829	getter_AddRefs(handle));
2830	#endif
2831
2832	if (entry) {
2833	// the entry is up to date
2834	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Skipping file because the entry is up to" " date. [name=%s]", leaf.get()); } } while (0)
2835	("CacheIndex::BuildIndex() - Skipping file because the entry is up to"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Skipping file because the entry is up to" " date. [name=%s]", leaf.get()); } } while (0)
2836	" date. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Skipping file because the entry is up to" " date. [name=%s]", leaf.get()); } } while (0)
2837	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Skipping file because the entry is up to" " date. [name=%s]", leaf.get()); } } while (0);
2838	entry->Log();
2839	MOZ_ASSERT(entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsFresh()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("entry->IsFresh()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2839); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsFresh()" ")"); do { ((volatile int)__null) = 2839; __attribute__((nomerge )) ::abort(); } while (false); } } while (false); // The entry must be from this session
2840	// there must be an active CacheFile if the entry is not initialized
2841	MOZ_ASSERT(entry->IsInitialized() \|\| handle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsInitialized() \|\| handle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsInitialized() \|\| handle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("entry->IsInitialized() \|\| handle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2841); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsInitialized() \|\| handle" ")"); do { ((volatile int)__null) = 2841; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2842	continue;
2843	}
2844
2845	MOZ_ASSERT(!handle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!handle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!handle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!handle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2845); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!handle" ")" ); do { ((volatile int)__null) = 2845; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2846
2847	RefPtr<CacheFileMetadata> meta = new CacheFileMetadata();
2848	int64_t size = 0;
2849
2850	{
2851	// Do not do IO under the lock.
2852	StaticMutexAutoUnlock unlock(sLock);
2853	rv = meta->SyncReadMetadata(file);
2854
2855	if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
2856	rv = file->GetFileSize(&size);
2857	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2858	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Cannot get filesize of file that was" " successfully parsed. [name=%s]", leaf.get()); } } while (0 )
2859	("CacheIndex::BuildIndex() - Cannot get filesize of file that was"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Cannot get filesize of file that was" " successfully parsed. [name=%s]", leaf.get()); } } while (0 )
2860	" successfully parsed. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Cannot get filesize of file that was" " successfully parsed. [name=%s]", leaf.get()); } } while (0 )
2861	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Cannot get filesize of file that was" " successfully parsed. [name=%s]", leaf.get()); } } while (0 );
2862	}
2863	}
2864	}
2865	if (mState == SHUTDOWN) {
2866	return;
2867	}
2868
2869	// Nobody could add the entry while the lock was released since we modify
2870	// the index only on IO thread and this loop is executed on IO thread too.
2871	entry = mIndex.GetEntry(hash);
2872	MOZ_ASSERT(!entry \|\| entry->IsRemoved())do { static_assert( mozilla::detail::AssertionConditionType< decltype(!entry \|\| entry->IsRemoved())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!entry \|\| entry->IsRemoved ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("!entry \|\| entry->IsRemoved()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2872); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!entry \|\| entry->IsRemoved()" ")"); do { ((volatile int)__null) = 2872; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2873
2874	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2875	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2876	("CacheIndex::BuildIndex() - CacheFileMetadata::SyncReadMetadata() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2877	"failed, removing file. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2878	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0);
2879	file->Remove(false);
2880	} else {
2881	CacheIndexEntryAutoManage entryMng(&hash, this, aProofOfLock);
2882	entry = mIndex.PutEntry(hash);
2883	if (NS_FAILED(InitEntryFromDiskData(entry, meta, size))((bool)(__builtin_expect(!!(NS_FAILED_impl(InitEntryFromDiskData (entry, meta, size))), 0)))) {
2884	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFile::InitEntryFromDiskData() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2885	("CacheIndex::BuildIndex() - CacheFile::InitEntryFromDiskData() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFile::InitEntryFromDiskData() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2886	"failed, removing file. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFile::InitEntryFromDiskData() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
2887	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - CacheFile::InitEntryFromDiskData() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0);
2888	file->Remove(false);
2889	entry->MarkRemoved();
2890	} else {
2891	LOG(("CacheIndex::BuildIndex() - Added entry to index. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Added entry to index. [name=%s]" , leaf.get()); } } while (0)
2892	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::BuildIndex() - Added entry to index. [name=%s]" , leaf.get()); } } while (0);
2893	entry->Log();
2894	}
2895	}
2896	}
2897
2898	MOZ_ASSERT_UNREACHABLE("We should never get here")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: " "We should never get here" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2898); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "MOZ_ASSERT_UNREACHABLE: " "We should never get here" ")"); do { ((volatile int)__null) = 2898; __attribute__((nomerge)) :: abort(); } while (false); } } while (false);
2899	}
2900
2901	bool CacheIndex::StartUpdatingIndexIfNeeded(
2902	const StaticMutexAutoLock& aProofOfLock, bool aSwitchingToReadyState) {
2903	sLock.AssertCurrentThreadOwns();
2904	// Start updating process when we are in or we are switching to READY state
2905	// and index needs update, but not during shutdown or when removing all
2906	// entries.
2907	if ((mState == READY \|\| aSwitchingToReadyState) && mIndexNeedsUpdate &&
2908	!mShuttingDown && !mRemovingAll) {
2909	LOG(("CacheIndex::StartUpdatingIndexIfNeeded() - starting update process"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndexIfNeeded() - starting update process" ); } } while (0);
2910	mIndexNeedsUpdate = false;
2911	StartUpdatingIndex(false, aProofOfLock);
2912	return true;
2913	}
2914
2915	return false;
2916	}
2917
2918	void CacheIndex::StartUpdatingIndex(bool aRebuild,
2919	const StaticMutexAutoLock& aProofOfLock) {
2920	sLock.AssertCurrentThreadOwns();
2921	LOG(("CacheIndex::StartUpdatingIndex() [rebuild=%d]", aRebuild))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() [rebuild=%d]" , aRebuild); } } while (0);
2922
2923	nsresult rv;
2924
2925	mIndexStats.Log();
2926
2927	ChangeState(aRebuild ? BUILDING : UPDATING, aProofOfLock);
2928	mDontMarkIndexClean = false;
2929
2930	if (mShuttingDown \|\| mRemovingAll) {
2931	FinishUpdate(false, aProofOfLock);
2932	return;
2933	}
2934
2935	if (IsUpdatePending()) {
2936	LOG(("CacheIndex::StartUpdatingIndex() - Update is already pending"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - Update is already pending" ); } } while (0);
2937	return;
2938	}
2939
2940	uint32_t elapsed = (TimeStamp::NowLoRes() - mStartTime).ToMilliseconds();
2941	if (elapsed < kUpdateIndexStartDelay50000) {
2942	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "scheduling timer to fire in %u ms.", elapsed, 50000 - elapsed ); } } while (0)
2943	("CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "scheduling timer to fire in %u ms.", elapsed, 50000 - elapsed ); } } while (0)
2944	"scheduling timer to fire in %u ms.",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "scheduling timer to fire in %u ms.", elapsed, 50000 - elapsed ); } } while (0)
2945	elapsed, kUpdateIndexStartDelay - elapsed))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "scheduling timer to fire in %u ms.", elapsed, 50000 - elapsed ); } } while (0);
2946	rv = ScheduleUpdateTimer(kUpdateIndexStartDelay50000 - elapsed);
2947	if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
2948	return;
2949	}
2950
2951	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - ScheduleUpdateTimer() failed. " "Starting update immediately."); } } while (0)
2952	("CacheIndex::StartUpdatingIndex() - ScheduleUpdateTimer() failed. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - ScheduleUpdateTimer() failed. " "Starting update immediately."); } } while (0)
2953	"Starting update immediately."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - ScheduleUpdateTimer() failed. " "Starting update immediately."); } } while (0);
2954	} else {
2955	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "starting update now.", elapsed); } } while (0)
2956	("CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "starting update now.", elapsed); } } while (0)
2957	"starting update now.",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "starting update now.", elapsed); } } while (0)
2958	elapsed))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - %u ms elapsed since startup, " "starting update now.", elapsed); } } while (0);
2959	}
2960
2961	RefPtr<CacheIOThread> ioThread = CacheFileIOManager::IOThread();
2962	MOZ_ASSERT(ioThread)do { static_assert( mozilla::detail::AssertionConditionType< decltype(ioThread)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(ioThread))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("ioThread", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2962); AnnotateMozCrashReason("MOZ_ASSERT" "(" "ioThread" ")" ); do { ((volatile int)__null) = 2962; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2963
2964	// We need to dispatch an event even if we are on IO thread since we need to
2965	// update the index with the correct priority.
2966	mUpdateEventPending = true;
2967	rv = ioThread->Dispatch(this, CacheIOThread::INDEX);
2968	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2969	mUpdateEventPending = false;
2970	NS_WARNING("CacheIndex::StartUpdatingIndex() - Can't dispatch event")NS_DebugBreak(NS_DEBUG_WARNING, "CacheIndex::StartUpdatingIndex() - Can't dispatch event" , nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2970);
2971	LOG(("CacheIndex::StartUpdatingIndex() - Can't dispatch event"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::StartUpdatingIndex() - Can't dispatch event" ); } } while (0);
2972	FinishUpdate(false, aProofOfLock);
2973	}
2974	}
2975
2976	void CacheIndex::UpdateIndex(const StaticMutexAutoLock& aProofOfLock) {
2977	sLock.AssertCurrentThreadOwns();
2978	LOG(("CacheIndex::UpdateIndex()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex()" ); } } while (0);
2979
2980	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 2980); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 2980; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
2981	sLock.AssertCurrentThreadOwns();
2982
2983	nsresult rv;
2984
2985	if (!mDirEnumerator) {
2986	rv = SetupDirectoryEnumerator();
2987	if (mState == SHUTDOWN) {
2988	// The index was shut down while we released the lock. FinishUpdate() was
2989	// already called from Shutdown(), so just simply return here.
2990	return;
2991	}
2992
2993	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
2994	FinishUpdate(false, aProofOfLock);
2995	return;
2996	}
2997	}
2998
2999	while (true) {
3000	if (CacheIOThread::YieldAndRerun()) {
3001	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Breaking loop for higher level " "events."); } } while (0)
3002	("CacheIndex::UpdateIndex() - Breaking loop for higher level "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Breaking loop for higher level " "events."); } } while (0)
3003	"events."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Breaking loop for higher level " "events."); } } while (0);
3004	mUpdateEventPending = true;
3005	return;
3006	}
3007
3008	bool fileExists = false;
3009	nsCOMPtr<nsIFile> file;
3010	{
3011	// Do not do IO under the lock.
3012	nsCOMPtr<nsIDirectoryEnumerator> dirEnumerator(mDirEnumerator);
3013	StaticMutexAutoUnlock unlock(sLock);
3014	rv = dirEnumerator->GetNextFile(getter_AddRefs(file));
3015
3016	if (file) {
3017	file->Exists(&fileExists);
3018	}
3019	}
3020	if (mState == SHUTDOWN) {
3021	return;
3022	}
3023	if (!file) {
3024	FinishUpdate(NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1))), aProofOfLock);
3025	return;
3026	}
3027
3028	nsAutoCString leaf;
3029	rv = file->GetNativeLeafName(leaf);
3030	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3031	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0)
3032	("CacheIndex::UpdateIndex() - GetNativeLeafName() failed! Skipping "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0)
3033	"file."))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - GetNativeLeafName() failed! Skipping " "file."); } } while (0);
3034	mDontMarkIndexClean = true;
3035	continue;
3036	}
3037
3038	if (!fileExists) {
3039	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
3040	("CacheIndex::UpdateIndex() - File returned by the iterator was "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
3041	"removed in the meantime [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0)
3042	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - File returned by the iterator was " "removed in the meantime [name=%s]", leaf.get()); } } while ( 0);
3043	continue;
3044	}
3045
3046	SHA1Sum::Hash hash;
3047	rv = CacheFileIOManager::StrToHash(leaf, &hash);
3048	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3049	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
3050	("CacheIndex::UpdateIndex() - Filename is not a hash, removing file. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
3051	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0)
3052	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Filename is not a hash, removing file. " "[name=%s]", leaf.get()); } } while (0);
3053	file->Remove(false);
3054	continue;
3055	}
3056
3057	CacheIndexEntry* entry = mIndex.GetEntry(hash);
3058	if (entry && entry->IsRemoved()) {
3059	if (entry->IsFresh()) {
3060	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
3061	("CacheIndex::UpdateIndex() - Found file that should not exist. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
3062	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0)
3063	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Found file that should not exist. " "[name=%s]", leaf.get()); } } while (0);
3064	entry->Log();
3065	}
3066	entry = nullptr;
3067	}
3068
3069	#ifdef DEBUG1
3070	RefPtr<CacheFileHandle> handle;
3071	CacheFileIOManager::gInstance->mHandles.GetHandle(&hash,
3072	getter_AddRefs(handle));
3073	#endif
3074
3075	if (entry && entry->IsFresh()) {
3076	// the entry is up to date
3077	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because the entry is up " " to date. [name=%s]", leaf.get()); } } while (0)
3078	("CacheIndex::UpdateIndex() - Skipping file because the entry is up "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because the entry is up " " to date. [name=%s]", leaf.get()); } } while (0)
3079	" to date. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because the entry is up " " to date. [name=%s]", leaf.get()); } } while (0)
3080	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because the entry is up " " to date. [name=%s]", leaf.get()); } } while (0);
3081	entry->Log();
3082	// there must be an active CacheFile if the entry is not initialized
3083	MOZ_ASSERT(entry->IsInitialized() \|\| handle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(entry->IsInitialized() \|\| handle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(entry->IsInitialized() \|\| handle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("entry->IsInitialized() \|\| handle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3083); AnnotateMozCrashReason("MOZ_ASSERT" "(" "entry->IsInitialized() \|\| handle" ")"); do { ((volatile int)__null) = 3083; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3084	continue;
3085	}
3086
3087	MOZ_ASSERT(!handle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!handle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!handle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!handle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3087); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!handle" ")" ); do { ((volatile int)__null) = 3087; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3088
3089	if (entry) {
3090	PRTime lastModifiedTime;
3091	{
3092	// Do not do IO under the lock.
3093	StaticMutexAutoUnlock unlock(sLock);
3094	rv = file->GetLastModifiedTime(&lastModifiedTime);
3095	}
3096	if (mState == SHUTDOWN) {
3097	return;
3098	}
3099	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3100	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get lastModifiedTime. " "[name=%s]", leaf.get()); } } while (0)
3101	("CacheIndex::UpdateIndex() - Cannot get lastModifiedTime. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get lastModifiedTime. " "[name=%s]", leaf.get()); } } while (0)
3102	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get lastModifiedTime. " "[name=%s]", leaf.get()); } } while (0)
3103	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get lastModifiedTime. " "[name=%s]", leaf.get()); } } while (0);
3104	// Assume the file is newer than index
3105	} else {
3106	if (mIndexTimeStamp > (lastModifiedTime / PR_MSEC_PER_SEC1000L)) {
3107	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0)
3108	("CacheIndex::UpdateIndex() - Skipping file because of last "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0)
3109	"modified time. [name=%s, indexTimeStamp=%" PRIu32 ", "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0)
3110	"lastModifiedTime=%" PRId64 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0)
3111	leaf.get(), mIndexTimeStamp,do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0)
3112	lastModifiedTime / PR_MSEC_PER_SEC))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Skipping file because of last " "modified time. [name=%s, indexTimeStamp=%" "u" ", " "lastModifiedTime=%" "l" "d" "]", leaf.get(), mIndexTimeStamp, lastModifiedTime / 1000L); } } while (0);
3113
3114	CacheIndexEntryAutoManage entryMng(&hash, this, aProofOfLock);
3115	entry->MarkFresh();
3116	continue;
3117	}
3118	}
3119	}
3120
3121	RefPtr<CacheFileMetadata> meta = new CacheFileMetadata();
3122	int64_t size = 0;
3123
3124	{
3125	// Do not do IO under the lock.
3126	StaticMutexAutoUnlock unlock(sLock);
3127	rv = meta->SyncReadMetadata(file);
3128
3129	if (NS_SUCCEEDED(rv)((bool)(__builtin_expect(!!(!NS_FAILED_impl(rv)), 1)))) {
3130	rv = file->GetFileSize(&size);
3131	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3132	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get filesize of file that " "was successfully parsed. [name=%s]", leaf.get()); } } while (0)
3133	("CacheIndex::UpdateIndex() - Cannot get filesize of file that "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get filesize of file that " "was successfully parsed. [name=%s]", leaf.get()); } } while (0)
3134	"was successfully parsed. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get filesize of file that " "was successfully parsed. [name=%s]", leaf.get()); } } while (0)
3135	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Cannot get filesize of file that " "was successfully parsed. [name=%s]", leaf.get()); } } while (0);
3136	}
3137	}
3138	}
3139	if (mState == SHUTDOWN) {
3140	return;
3141	}
3142
3143	// Nobody could add the entry while the lock was released since we modify
3144	// the index only on IO thread and this loop is executed on IO thread too.
3145	entry = mIndex.GetEntry(hash);
3146	MOZ_ASSERT(!entry \|\| !entry->IsFresh())do { static_assert( mozilla::detail::AssertionConditionType< decltype(!entry \|\| !entry->IsFresh())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!entry \|\| !entry->IsFresh ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("!entry \|\| !entry->IsFresh()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3146); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!entry \|\| !entry->IsFresh()" ")"); do { ((volatile int)__null) = 3146; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3147
3148	CacheIndexEntryAutoManage entryMng(&hash, this, aProofOfLock);
3149
3150	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3151	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3152	("CacheIndex::UpdateIndex() - CacheFileMetadata::SyncReadMetadata() "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3153	"failed, removing file. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3154	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheFileMetadata::SyncReadMetadata() " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0);
3155	} else {
3156	entry = mIndex.PutEntry(hash);
3157	rv = InitEntryFromDiskData(entry, meta, size);
3158	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3159	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheIndex::InitEntryFromDiskData " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3160	("CacheIndex::UpdateIndex() - CacheIndex::InitEntryFromDiskData "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheIndex::InitEntryFromDiskData " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3161	"failed, removing file. [name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheIndex::InitEntryFromDiskData " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0)
3162	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - CacheIndex::InitEntryFromDiskData " "failed, removing file. [name=%s]", leaf.get()); } } while ( 0);
3163	}
3164	}
3165
3166	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3167	file->Remove(false);
3168	if (entry) {
3169	entry->MarkRemoved();
3170	entry->MarkFresh();
3171	entry->MarkDirty();
3172	}
3173	} else {
3174	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Added/updated entry to/in index. " "[name=%s]", leaf.get()); } } while (0)
3175	("CacheIndex::UpdateIndex() - Added/updated entry to/in index. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Added/updated entry to/in index. " "[name=%s]", leaf.get()); } } while (0)
3176	"[name=%s]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Added/updated entry to/in index. " "[name=%s]", leaf.get()); } } while (0)
3177	leaf.get()))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::UpdateIndex() - Added/updated entry to/in index. " "[name=%s]", leaf.get()); } } while (0);
3178	entry->Log();
3179	}
3180	}
3181
3182	MOZ_ASSERT_UNREACHABLE("We should never get here")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "MOZ_ASSERT_UNREACHABLE: " "We should never get here" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3182); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "MOZ_ASSERT_UNREACHABLE: " "We should never get here" ")"); do { ((volatile int)__null) = 3182; __attribute__((nomerge)) :: abort(); } while (false); } } while (false);
3183	}
3184
3185	void CacheIndex::FinishUpdate(bool aSucceeded,
3186	const StaticMutexAutoLock& aProofOfLock) {
3187	LOG(("CacheIndex::FinishUpdate() [succeeded=%d]", aSucceeded))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishUpdate() [succeeded=%d]" , aSucceeded); } } while (0);
3188
3189	MOZ_ASSERT(mState == UPDATING \|\| mState == BUILDING \|\|do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN))) ), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3190); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN)" ")"); do { ((volatile int)__null) = 3190; __attribute__((nomerge )) ::abort(); } while (false); } } while (false)
3190	(!aSucceeded && mState == SHUTDOWN))do { static_assert( mozilla::detail::AssertionConditionType< decltype(mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN))) ), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3190); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mState == UPDATING \|\| mState == BUILDING \|\| (!aSucceeded && mState == SHUTDOWN)" ")"); do { ((volatile int)__null) = 3190; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3191
3192	if (mDirEnumerator) {
3193	if (NS_IsMainThread()) {
3194	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishUpdate() - posting of PreShutdownInternal failed?" " Cannot safely release mDirEnumerator, leaking it!"); } } while (0)
3195	("CacheIndex::FinishUpdate() - posting of PreShutdownInternal failed?"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishUpdate() - posting of PreShutdownInternal failed?" " Cannot safely release mDirEnumerator, leaking it!"); } } while (0)
3196	" Cannot safely release mDirEnumerator, leaking it!"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FinishUpdate() - posting of PreShutdownInternal failed?" " Cannot safely release mDirEnumerator, leaking it!"); } } while (0);
3197	NS_WARNING(("CacheIndex::FinishUpdate() - Leaking mDirEnumerator!"))NS_DebugBreak(NS_DEBUG_WARNING, ("CacheIndex::FinishUpdate() - Leaking mDirEnumerator!" ), nullptr, "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3197);
3198	// This can happen only in case dispatching event to IO thread failed in
3199	// CacheIndex::PreShutdown().
3200	Unused << mDirEnumerator.forget(); // Leak it since dir enumerator is not
3201	// threadsafe
3202	} else {
3203	mDirEnumerator->Close();
3204	mDirEnumerator = nullptr;
3205	}
3206	}
3207
3208	if (!aSucceeded) {
3209	mDontMarkIndexClean = true;
3210	}
3211
3212	if (mState == SHUTDOWN) {
3213	return;
3214	}
3215
3216	if (mState == UPDATING && aSucceeded) {
3217	// If we've iterated over all entries successfully then all entries that
3218	// really exist on the disk are now marked as fresh. All non-fresh entries
3219	// don't exist anymore and must be removed from the index.
3220	RemoveNonFreshEntries(aProofOfLock);
3221	}
3222
3223	// Make sure we won't start update. If the build or update failed, there is no
3224	// reason to believe that it will succeed next time.
3225	mIndexNeedsUpdate = false;
3226
3227	ChangeState(READY, aProofOfLock);
3228	mLastDumpTime = TimeStamp::NowLoRes(); // Do not dump new index immediately
3229	}
3230
3231	void CacheIndex::RemoveNonFreshEntries(
3232	const StaticMutexAutoLock& aProofOfLock) {
3233	sLock.AssertCurrentThreadOwns();
3234	for (auto iter = mIndex.Iter(); !iter.Done(); iter.Next()) {
3235	CacheIndexEntry* entry = iter.Get();
3236	if (entry->IsFresh()) {
3237	continue;
3238	}
3239
3240	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveNonFreshEntries() - Removing entry. " "[hash=%08x%08x%08x%08x%08x]", PR_htonl((reinterpret_cast< const uint32_t>(entry->Hash()))[0]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 )
3241	("CacheIndex::RemoveNonFreshEntries() - Removing entry. "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveNonFreshEntries() - Removing entry. " "[hash=%08x%08x%08x%08x%08x]", PR_htonl((reinterpret_cast< const uint32_t>(entry->Hash()))[0]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 )
3242	"[hash=%08x%08x%08x%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveNonFreshEntries() - Removing entry. " "[hash=%08x%08x%08x%08x%08x]", PR_htonl((reinterpret_cast< const uint32_t>(entry->Hash()))[0]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 )
3243	LOGSHA1(entry->Hash())))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::RemoveNonFreshEntries() - Removing entry. " "[hash=%08x%08x%08x%08x%08x]", PR_htonl((reinterpret_cast< const uint32_t>(entry->Hash()))[0]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[1]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[2]), PR_htonl((reinterpret_cast <const uint32_t>(entry->Hash()))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(entry->Hash()))[4])); } } while (0 );
3244
3245	{
3246	CacheIndexEntryAutoManage emng(entry->Hash(), this, aProofOfLock);
3247	emng.DoNotSearchInIndex();
3248	}
3249
3250	iter.Remove();
3251	}
3252	}
3253
3254	// static
3255	char const* CacheIndex::StateString(EState aState) {
3256	switch (aState) {
3257	case INITIAL:
3258	return "INITIAL";
3259	case READING:
3260	return "READING";
3261	case WRITING:
3262	return "WRITING";
3263	case BUILDING:
3264	return "BUILDING";
3265	case UPDATING:
3266	return "UPDATING";
3267	case READY:
3268	return "READY";
3269	case SHUTDOWN:
3270	return "SHUTDOWN";
3271	}
3272
3273	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3273); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 3273 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
3274	return "?";
3275	}
3276
3277	void CacheIndex::ChangeState(EState aNewState,
3278	const StaticMutexAutoLock& aProofOfLock) {
3279	sLock.AssertCurrentThreadOwns();
3280	LOG(("CacheIndex::ChangeState() changing state %s -> %s", StateString(mState),do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ChangeState() changing state %s -> %s" , StateString(mState), StateString(aNewState)); } } while (0)
3281	StateString(aNewState)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ChangeState() changing state %s -> %s" , StateString(mState), StateString(aNewState)); } } while (0);
3282
3283	// All pending updates should be processed before changing state
3284	MOZ_ASSERT(mPendingUpdates.Count() == 0)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mPendingUpdates.Count() == 0)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mPendingUpdates.Count() == 0 ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mPendingUpdates.Count() == 0", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3284); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mPendingUpdates.Count() == 0" ")"); do { ((volatile int)__null) = 3284; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3285
3286	// PreShutdownInternal() should change the state to READY from every state. It
3287	// may go through different states, but once we are in READY state the only
3288	// possible transition is to SHUTDOWN state.
3289	MOZ_ASSERT(!mShuttingDown \|\| mState != READY \|\| aNewState == SHUTDOWN)do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mShuttingDown \|\| mState != READY \|\| aNewState == SHUTDOWN )>::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(!mShuttingDown \|\| mState != READY \|\| aNewState == SHUTDOWN ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "!mShuttingDown \|\| mState != READY \|\| aNewState == SHUTDOWN", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3289); AnnotateMozCrashReason("MOZ_ASSERT" "(" "!mShuttingDown \|\| mState != READY \|\| aNewState == SHUTDOWN" ")"); do { ((volatile int)__null) = 3289; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3290
3291	// Start updating process when switching to READY state if needed
3292	if (aNewState == READY && StartUpdatingIndexIfNeeded(aProofOfLock, true)) {
3293	return;
3294	}
3295
3296	// Try to evict entries over limit everytime we're leaving state READING,
3297	// BUILDING or UPDATING, but not during shutdown or when removing all
3298	// entries.
3299	if (!mShuttingDown && !mRemovingAll && aNewState != SHUTDOWN &&
3300	(mState == READING \|\| mState == BUILDING \|\| mState == UPDATING)) {
3301	CacheFileIOManager::EvictIfOverLimit();
3302	}
3303
3304	mState = aNewState;
3305
3306	if (mState != SHUTDOWN) {
3307	CacheFileIOManager::CacheIndexStateChanged();
3308	}
3309
3310	NotifyAsyncGetDiskConsumptionCallbacks();
3311	}
3312
3313	void CacheIndex::NotifyAsyncGetDiskConsumptionCallbacks() {
3314	if ((mState == READY \|\| mState == WRITING) &&
3315	!mAsyncGetDiskConsumptionBlocked && mDiskConsumptionObservers.Length()) {
3316	for (uint32_t i = 0; i < mDiskConsumptionObservers.Length(); ++i) {
3317	DiskConsumptionObserver* o = mDiskConsumptionObservers[i];
3318	// Safe to call under the lock. We always post to the main thread.
3319	o->OnDiskConsumption(mIndexStats.Size() << 10);
3320	}
3321
3322	mDiskConsumptionObservers.Clear();
3323	}
3324	}
3325
3326	void CacheIndex::AllocBuffer() {
3327	switch (mState) {
3328	case WRITING:
3329	mRWBufSize = sizeof(CacheIndexHeader) + sizeof(CacheHash::Hash32_t) +
3330	mProcessEntries * sizeof(CacheIndexRecord);
3331	if (mRWBufSize > kMaxBufSize16384) {
3332	mRWBufSize = kMaxBufSize16384;
3333	}
3334	break;
3335	case READING:
3336	mRWBufSize = kMaxBufSize16384;
3337	break;
3338	default:
3339	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3339); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 3339 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
3340	}
3341
3342	mRWBuf = static_cast<char*>(moz_xmalloc(mRWBufSize));
3343	}
3344
3345	void CacheIndex::ReleaseBuffer() {
3346	sLock.AssertCurrentThreadOwns();
3347
3348	if (!mRWBuf \|\| mRWPending) {
3349	return;
3350	}
3351
3352	LOG(("CacheIndex::ReleaseBuffer() releasing buffer"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::ReleaseBuffer() releasing buffer" ); } } while (0);
3353
3354	free(mRWBuf);
3355	mRWBuf = nullptr;
3356	mRWBufSize = 0;
3357	mRWBufPos = 0;
3358	}
3359
3360	void CacheIndex::FrecencyArray::AppendRecord(
3361	CacheIndexRecordWrapper* aRecord, const StaticMutexAutoLock& aProofOfLock) {
3362	sLock.AssertCurrentThreadOwns();
3363	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::AppendRecord() [record=%p, hash=%08x%08x%08x" "%08x%08x]", aRecord, PR_htonl((reinterpret_cast<const uint32_t >(aRecord->Get()->mHash))[0]), PR_htonl((reinterpret_cast <const uint32_t>(aRecord->Get()->mHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aRecord->Get()-> mHash))[2]), PR_htonl((reinterpret_cast<const uint32_t> (aRecord->Get()->mHash))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aRecord->Get()->mHash))[4])); } } while (0)
3364	("CacheIndex::FrecencyArray::AppendRecord() [record=%p, hash=%08x%08x%08x"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::AppendRecord() [record=%p, hash=%08x%08x%08x" "%08x%08x]", aRecord, PR_htonl((reinterpret_cast<const uint32_t >(aRecord->Get()->mHash))[0]), PR_htonl((reinterpret_cast <const uint32_t>(aRecord->Get()->mHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aRecord->Get()-> mHash))[2]), PR_htonl((reinterpret_cast<const uint32_t> (aRecord->Get()->mHash))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aRecord->Get()->mHash))[4])); } } while (0)
3365	"%08x%08x]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::AppendRecord() [record=%p, hash=%08x%08x%08x" "%08x%08x]", aRecord, PR_htonl((reinterpret_cast<const uint32_t >(aRecord->Get()->mHash))[0]), PR_htonl((reinterpret_cast <const uint32_t>(aRecord->Get()->mHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aRecord->Get()-> mHash))[2]), PR_htonl((reinterpret_cast<const uint32_t> (aRecord->Get()->mHash))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aRecord->Get()->mHash))[4])); } } while (0)
3366	aRecord, LOGSHA1(aRecord->Get()->mHash)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::AppendRecord() [record=%p, hash=%08x%08x%08x" "%08x%08x]", aRecord, PR_htonl((reinterpret_cast<const uint32_t >(aRecord->Get()->mHash))[0]), PR_htonl((reinterpret_cast <const uint32_t>(aRecord->Get()->mHash))[1]), PR_htonl ((reinterpret_cast<const uint32_t>(aRecord->Get()-> mHash))[2]), PR_htonl((reinterpret_cast<const uint32_t> (aRecord->Get()->mHash))[3]), PR_htonl((reinterpret_cast <const uint32_t*>(aRecord->Get()->mHash))[4])); } } while (0);
3367
3368	MOZ_DIAGNOSTIC_ASSERT(!mRecs.Contains(aRecord))do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRecs.Contains(aRecord))>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRecs.Contains(aRecord)))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRecs.Contains(aRecord)" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3368); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "!mRecs.Contains(aRecord)" ")"); do { ((volatile int)__null) = 3368; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3369	mRecs.AppendElement(aRecord);
3370
3371	// If the new frecency is 0, the element should be at the end of the array,
3372	// i.e. this change doesn't affect order of the array
3373	if (aRecord->Get()->mFrecency != 0) {
3374	++mUnsortedElements;
3375	}
3376	}
3377
3378	void CacheIndex::FrecencyArray::RemoveRecord(
3379	CacheIndexRecordWrapper* aRecord, const StaticMutexAutoLock& aProofOfLock) {
3380	sLock.AssertCurrentThreadOwns();
3381	LOG(("CacheIndex::FrecencyArray::RemoveRecord() [record=%p]", aRecord))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::RemoveRecord() [record=%p]" , aRecord); } } while (0);
3382
3383	decltype(mRecs)::index_type idx;
3384	idx = mRecs.IndexOf(aRecord);
3385	MOZ_RELEASE_ASSERT(idx != mRecs.NoIndex)do { static_assert( mozilla::detail::AssertionConditionType< decltype(idx != mRecs.NoIndex)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(idx != mRecs.NoIndex))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("idx != mRecs.NoIndex" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3385); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "idx != mRecs.NoIndex" ")"); do { ((volatile int)__null) = 3385; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3386	// sanity check to ensure correct record removal
3387	MOZ_RELEASE_ASSERT(mRecs[idx] == aRecord)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRecs[idx] == aRecord)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRecs[idx] == aRecord))), 0) )) { do { } while (false); MOZ_ReportAssertionFailure("mRecs[idx] == aRecord" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3387); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "mRecs[idx] == aRecord" ")"); do { ((volatile int)__null) = 3387; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3388	mRecs[idx] = nullptr;
3389	++mRemovedElements;
3390
3391	// Calling SortIfNeeded ensures that we get rid of removed elements in the
3392	// array once we hit the limit.
3393	SortIfNeeded(aProofOfLock);
3394	}
3395
3396	void CacheIndex::FrecencyArray::ReplaceRecord(
3397	CacheIndexRecordWrapper* aOldRecord, CacheIndexRecordWrapper* aNewRecord,
3398	const StaticMutexAutoLock& aProofOfLock) {
3399	sLock.AssertCurrentThreadOwns();
3400	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::ReplaceRecord() [oldRecord=%p, " "newRecord=%p]", aOldRecord, aNewRecord); } } while (0)
3401	("CacheIndex::FrecencyArray::ReplaceRecord() [oldRecord=%p, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::ReplaceRecord() [oldRecord=%p, " "newRecord=%p]", aOldRecord, aNewRecord); } } while (0)
3402	"newRecord=%p]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::ReplaceRecord() [oldRecord=%p, " "newRecord=%p]", aOldRecord, aNewRecord); } } while (0)
3403	aOldRecord, aNewRecord))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::ReplaceRecord() [oldRecord=%p, " "newRecord=%p]", aOldRecord, aNewRecord); } } while (0);
3404
3405	decltype(mRecs)::index_type idx;
3406	idx = mRecs.IndexOf(aOldRecord);
3407	MOZ_RELEASE_ASSERT(idx != mRecs.NoIndex)do { static_assert( mozilla::detail::AssertionConditionType< decltype(idx != mRecs.NoIndex)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(idx != mRecs.NoIndex))), 0)) ) { do { } while (false); MOZ_ReportAssertionFailure("idx != mRecs.NoIndex" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3407); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "idx != mRecs.NoIndex" ")"); do { ((volatile int)__null) = 3407; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3408	// sanity check to ensure correct record replaced
3409	MOZ_RELEASE_ASSERT(mRecs[idx] == aOldRecord)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRecs[idx] == aOldRecord)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRecs[idx] == aOldRecord))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRecs[idx] == aOldRecord" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3409); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "mRecs[idx] == aOldRecord" ")"); do { ((volatile int)__null) = 3409; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3410	mRecs[idx] = aNewRecord;
3411	}
3412
3413	void CacheIndex::FrecencyArray::SortIfNeeded(
3414	const StaticMutexAutoLock& aProofOfLock) {
3415	sLock.AssertCurrentThreadOwns();
3416	const uint32_t kMaxUnsortedCount = 512;
3417	const uint32_t kMaxUnsortedPercent = 10;
3418	const uint32_t kMaxRemovedCount = 512;
3419
3420	uint32_t unsortedLimit = std::min<uint32_t>(
3421	kMaxUnsortedCount, Length() * kMaxUnsortedPercent / 100);
3422
3423	if (mUnsortedElements > unsortedLimit \|\|
3424	mRemovedElements > kMaxRemovedCount) {
3425	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array " "[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, " "maxRemovedCount=%u]", mUnsortedElements, unsortedLimit, mRemovedElements , kMaxRemovedCount); } } while (0)
3426	("CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array " "[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, " "maxRemovedCount=%u]", mUnsortedElements, unsortedLimit, mRemovedElements , kMaxRemovedCount); } } while (0)
3427	"[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array " "[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, " "maxRemovedCount=%u]", mUnsortedElements, unsortedLimit, mRemovedElements , kMaxRemovedCount); } } while (0)
3428	"maxRemovedCount=%u]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array " "[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, " "maxRemovedCount=%u]", mUnsortedElements, unsortedLimit, mRemovedElements , kMaxRemovedCount); } } while (0)
3429	mUnsortedElements, unsortedLimit, mRemovedElements, kMaxRemovedCount))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::FrecencyArray::SortIfNeeded() - Sorting array " "[unsortedElements=%u, unsortedLimit=%u, removedElements=%u, " "maxRemovedCount=%u]", mUnsortedElements, unsortedLimit, mRemovedElements , kMaxRemovedCount); } } while (0);
3430
3431	mRecs.Sort(FrecencyComparator());
3432	mUnsortedElements = 0;
3433	if (mRemovedElements) {
3434	#if defined(EARLY_BETA_OR_EARLIER1)
3435	// validate only null items are removed
3436	for (uint32_t i = Length(); i < mRecs.Length(); ++i) {
3437	MOZ_DIAGNOSTIC_ASSERT(!mRecs[i])do { static_assert( mozilla::detail::AssertionConditionType< decltype(!mRecs[i])>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(!mRecs[i]))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("!mRecs[i]", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3437); AnnotateMozCrashReason("MOZ_DIAGNOSTIC_ASSERT" "(" "!mRecs[i]" ")"); do { ((volatile int)__null) = 3437; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3438	}
3439	#endif
3440	// Removed elements are at the end after sorting.
3441	mRecs.RemoveElementsAt(Length(), mRemovedElements);
3442	mRemovedElements = 0;
3443	}
3444	}
3445	}
3446
3447	bool CacheIndex::FrecencyArray::RecordExistedUnlocked(
3448	CacheIndexRecordWrapper* aRecord) {
3449	return mRecs.Contains(aRecord);
3450	}
3451
3452	void CacheIndex::AddRecordToIterators(CacheIndexRecordWrapper* aRecord,
3453	const StaticMutexAutoLock& aProofOfLock) {
3454	sLock.AssertCurrentThreadOwns();
3455	for (uint32_t i = 0; i < mIterators.Length(); ++i) {
3456	// Add a new record only when iterator is supposed to be updated.
3457	if (mIterators[i]->ShouldBeNewAdded()) {
3458	mIterators[i]->AddRecord(aRecord, aProofOfLock);
3459	}
3460	}
3461	}
3462
3463	void CacheIndex::RemoveRecordFromIterators(
3464	CacheIndexRecordWrapper* aRecord, const StaticMutexAutoLock& aProofOfLock) {
3465	sLock.AssertCurrentThreadOwns();
3466	for (uint32_t i = 0; i < mIterators.Length(); ++i) {
3467	// Remove the record from iterator always, it makes no sence to return
3468	// non-existing entries. Also the pointer to the record is no longer valid
3469	// once the entry is removed from index.
3470	mIterators[i]->RemoveRecord(aRecord, aProofOfLock);
3471	}
3472	}
3473
3474	void CacheIndex::ReplaceRecordInIterators(
3475	CacheIndexRecordWrapper* aOldRecord, CacheIndexRecordWrapper* aNewRecord,
3476	const StaticMutexAutoLock& aProofOfLock) {
3477	sLock.AssertCurrentThreadOwns();
3478	for (uint32_t i = 0; i < mIterators.Length(); ++i) {
3479	// We have to replace the record always since the pointer is no longer
3480	// valid after this point. NOTE: Replacing the record doesn't mean that
3481	// a new entry was added, it just means that the data in the entry was
3482	// changed (e.g. a file size) and we had to track this change in
3483	// mPendingUpdates since mIndex was read-only.
3484	mIterators[i]->ReplaceRecord(aOldRecord, aNewRecord, aProofOfLock);
3485	}
3486	}
3487
3488	nsresult CacheIndex::Run() {
3489	LOG(("CacheIndex::Run()"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Run()" ); } } while (0);
3490
3491	StaticMutexAutoLock lock(sLock);
3492
3493	if (!IsIndexUsable()) {
3494	return NS_ERROR_NOT_AVAILABLE;
3495	}
3496
3497	if (mState == READY && mShuttingDown) {
3498	return NS_OK;
3499	}
3500
3501	mUpdateEventPending = false;
3502
3503	switch (mState) {
3504	case BUILDING:
3505	BuildIndex(lock);
3506	break;
3507	case UPDATING:
3508	UpdateIndex(lock);
3509	break;
3510	default:
3511	LOG(("CacheIndex::Run() - Update/Build was canceled"))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::Run() - Update/Build was canceled" ); } } while (0);
3512	}
3513
3514	return NS_OK;
3515	}
3516
3517	void CacheIndex::OnFileOpenedInternal(FileOpenHelper* aOpener,
3518	CacheFileHandle* aHandle,
3519	nsresult aResult,
3520	const StaticMutexAutoLock& aProofOfLock) {
3521	sLock.AssertCurrentThreadOwns();
3522	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() [opener=%p, handle=%p, " "result=0x%08" "x" "]", aOpener, aHandle, static_cast<uint32_t >(aResult)); } } while (0)
3523	("CacheIndex::OnFileOpenedInternal() [opener=%p, handle=%p, "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() [opener=%p, handle=%p, " "result=0x%08" "x" "]", aOpener, aHandle, static_cast<uint32_t >(aResult)); } } while (0)
3524	"result=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() [opener=%p, handle=%p, " "result=0x%08" "x" "]", aOpener, aHandle, static_cast<uint32_t >(aResult)); } } while (0)
3525	aOpener, aHandle, static_cast<uint32_t>(aResult)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() [opener=%p, handle=%p, " "result=0x%08" "x" "]", aOpener, aHandle, static_cast<uint32_t >(aResult)); } } while (0);
3526	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3526); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 3526; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3527
3528	nsresult rv;
3529
3530	MOZ_RELEASE_ASSERT(IsIndexUsable())do { static_assert( mozilla::detail::AssertionConditionType< decltype(IsIndexUsable())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(IsIndexUsable()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsIndexUsable()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3530); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "IsIndexUsable()" ")"); do { ((volatile int)__null) = 3530; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3531
3532	if (mState == READY && mShuttingDown) {
3533	return;
3534	}
3535
3536	switch (mState) {
3537	case WRITING:
3538	MOZ_ASSERT(aOpener == mIndexFileOpener)do { static_assert( mozilla::detail::AssertionConditionType< decltype(aOpener == mIndexFileOpener)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(aOpener == mIndexFileOpener) )), 0))) { do { } while (false); MOZ_ReportAssertionFailure("aOpener == mIndexFileOpener" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3538); AnnotateMozCrashReason("MOZ_ASSERT" "(" "aOpener == mIndexFileOpener" ")"); do { ((volatile int)__null) = 3538; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3539	mIndexFileOpener = nullptr;
3540
3541	if (NS_FAILED(aResult)((bool)(__builtin_expect(!!(NS_FAILED_impl(aResult)), 0)))) {
3542	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Can't open index file for " "writing [rv=0x%08" "x" "]", static_cast<uint32_t>(aResult )); } } while (0)
3543	("CacheIndex::OnFileOpenedInternal() - Can't open index file for "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Can't open index file for " "writing [rv=0x%08" "x" "]", static_cast<uint32_t>(aResult )); } } while (0)
3544	"writing [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Can't open index file for " "writing [rv=0x%08" "x" "]", static_cast<uint32_t>(aResult )); } } while (0)
3545	static_cast<uint32_t>(aResult)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Can't open index file for " "writing [rv=0x%08" "x" "]", static_cast<uint32_t>(aResult )); } } while (0);
3546	FinishWrite(false, aProofOfLock);
3547	} else {
3548	mIndexHandle = aHandle;
3549	WriteRecords(aProofOfLock);
3550	}
3551	break;
3552	case READING:
3553	if (aOpener == mIndexFileOpener) {
3554	mIndexFileOpener = nullptr;
3555
3556	if (NS_SUCCEEDED(aResult)((bool)(__builtin_expect(!!(!NS_FAILED_impl(aResult)), 1)))) {
3557	if (aHandle->FileSize() == 0) {
3558	FinishRead(false, aProofOfLock);
3559	CacheFileIOManager::DoomFile(aHandle, nullptr);
3560	break;
3561	}
3562	mIndexHandle = aHandle;
3563	} else {
3564	FinishRead(false, aProofOfLock);
3565	break;
3566	}
3567	} else if (aOpener == mJournalFileOpener) {
3568	mJournalFileOpener = nullptr;
3569	mJournalHandle = aHandle;
3570	} else if (aOpener == mTmpFileOpener) {
3571	mTmpFileOpener = nullptr;
3572	mTmpHandle = aHandle;
3573	} else {
3574	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3574); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 3574 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
3575	}
3576
3577	if (mIndexFileOpener \|\| mJournalFileOpener \|\| mTmpFileOpener) {
3578	// Some opener still didn't finish
3579	break;
3580	}
3581
3582	// We fail and cancel all other openers when we opening index file fails.
3583	MOZ_ASSERT(mIndexHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mIndexHandle))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mIndexHandle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3583); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexHandle" ")"); do { ((volatile int)__null) = 3583; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3584
3585	if (mTmpHandle) {
3586	CacheFileIOManager::DoomFile(mTmpHandle, nullptr);
3587	mTmpHandle = nullptr;
3588
3589	if (mJournalHandle) { // this shouldn't normally happen
3590	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Unexpected state, all " "files [%s, %s, %s] should never exist. Removing whole index." , "index", "index.log", "index.tmp"); } } while (0)
3591	("CacheIndex::OnFileOpenedInternal() - Unexpected state, all "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Unexpected state, all " "files [%s, %s, %s] should never exist. Removing whole index." , "index", "index.log", "index.tmp"); } } while (0)
3592	"files [%s, %s, %s] should never exist. Removing whole index.",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Unexpected state, all " "files [%s, %s, %s] should never exist. Removing whole index." , "index", "index.log", "index.tmp"); } } while (0)
3593	INDEX_NAME, JOURNAL_NAME, TEMP_INDEX_NAME))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - Unexpected state, all " "files [%s, %s, %s] should never exist. Removing whole index." , "index", "index.log", "index.tmp"); } } while (0);
3594	FinishRead(false, aProofOfLock);
3595	break;
3596	}
3597	}
3598
3599	if (mJournalHandle) {
3600	// Rename journal to make sure we update index on next start in case
3601	// firefox crashes
3602	rv = CacheFileIOManager::RenameFile(
3603	mJournalHandle, nsLiteralCString(TEMP_INDEX_NAME"index.tmp"), this);
3604	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3605	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3606	("CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3607	"RenameFile() failed synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3608	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileOpenedInternal() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0);
3609	FinishRead(false, aProofOfLock);
3610	break;
3611	}
3612	} else {
3613	StartReadingIndex(aProofOfLock);
3614	}
3615
3616	break;
3617	default:
3618	MOZ_ASSERT(false, "Unexpected state!")do { static_assert( mozilla::detail::AssertionConditionType< decltype(false)>::isValid, "invalid assertion condition"); if ((__builtin_expect(!!(!(!!(false))), 0))) { do { } while ( false); MOZ_ReportAssertionFailure("false" " (" "Unexpected state!" ")", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3618); AnnotateMozCrashReason("MOZ_ASSERT" "(" "false" ") (" "Unexpected state!" ")"); do { ((volatile int)__null) = 3618 ; __attribute__((nomerge)) ::abort(); } while (false); } } while (false);
3619	}
3620	}
3621
3622	nsresult CacheIndex::OnFileOpened(CacheFileHandle* aHandle, nsresult aResult) {
3623	MOZ_CRASH("CacheIndex::OnFileOpened should not be called!")do { do { } while (false); MOZ_ReportCrash("" "CacheIndex::OnFileOpened should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3623); AnnotateMozCrashReason("MOZ_CRASH(" "CacheIndex::OnFileOpened should not be called!" ")"); do { ((volatile int)__null) = 3623; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
3624	return NS_ERROR_UNEXPECTED;
3625	}
3626
3627	nsresult CacheIndex::OnDataWritten(CacheFileHandle* aHandle, const char* aBuf,
3628	nsresult aResult) {
3629	LOG(("CacheIndex::OnDataWritten() [handle=%p, result=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0)
3630	aHandle, static_cast<uint32_t>(aResult)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0);
3631
3632	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3632); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 3632; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3633
3634	nsresult rv;
3635
3636	StaticMutexAutoLock lock(sLock);
3637
3638	MOZ_RELEASE_ASSERT(IsIndexUsable())do { static_assert( mozilla::detail::AssertionConditionType< decltype(IsIndexUsable())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(IsIndexUsable()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsIndexUsable()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3638); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "IsIndexUsable()" ")"); do { ((volatile int)__null) = 3638; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3639	MOZ_RELEASE_ASSERT(mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3639); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "mRWPending" ")"); do { ((volatile int)__null) = 3639; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3640	mRWPending = false;
3641
3642	if (mState == READY && mShuttingDown) {
3643	return NS_OK;
3644	}
3645
3646	switch (mState) {
3647	case WRITING:
3648	MOZ_ASSERT(mIndexHandle == aHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexHandle == aHandle)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mIndexHandle == aHandle))), 0 ))) { do { } while (false); MOZ_ReportAssertionFailure("mIndexHandle == aHandle" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3648); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexHandle == aHandle" ")"); do { ((volatile int)__null) = 3648; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3649
3650	if (NS_FAILED(aResult)((bool)(__builtin_expect(!!(NS_FAILED_impl(aResult)), 0)))) {
3651	FinishWrite(false, lock);
3652	} else {
3653	if (mSkipEntries == mProcessEntries) {
3654	rv = CacheFileIOManager::RenameFile(
3655	mIndexHandle, nsLiteralCString(INDEX_NAME"index"), this);
3656	if (NS_FAILED(rv)((bool)(__builtin_expect(!!(NS_FAILED_impl(rv)), 0)))) {
3657	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3658	("CacheIndex::OnDataWritten() - CacheFileIOManager::"do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3659	"RenameFile() failed synchronously [rv=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0)
3660	static_cast<uint32_t>(rv)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - CacheFileIOManager::" "RenameFile() failed synchronously [rv=0x%08" "x" "]", static_cast <uint32_t>(rv)); } } while (0);
3661	FinishWrite(false, lock);
3662	}
3663	} else {
3664	WriteRecords(lock);
3665	}
3666	}
3667	break;
3668	default:
3669	// Writing was canceled.
3670	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3671	("CacheIndex::OnDataWritten() - ignoring notification since the "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3672	"operation was previously canceled [state=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3673	mState))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataWritten() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0);
3674	ReleaseBuffer();
3675	}
3676
3677	return NS_OK;
3678	}
3679
3680	nsresult CacheIndex::OnDataRead(CacheFileHandle* aHandle, char* aBuf,
3681	nsresult aResult) {
3682	LOG(("CacheIndex::OnDataRead() [handle=%p, result=0x%08" PRIx32 "]", aHandle,do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0)
3683	static_cast<uint32_t>(aResult)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0);
3684
3685	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3685); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 3685; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3686
3687	StaticMutexAutoLock lock(sLock);
3688
3689	MOZ_RELEASE_ASSERT(IsIndexUsable())do { static_assert( mozilla::detail::AssertionConditionType< decltype(IsIndexUsable())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(IsIndexUsable()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsIndexUsable()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3689); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "IsIndexUsable()" ")"); do { ((volatile int)__null) = 3689; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3690	MOZ_RELEASE_ASSERT(mRWPending)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mRWPending)>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(mRWPending))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("mRWPending", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3690); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "mRWPending" ")"); do { ((volatile int)__null) = 3690; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3691	mRWPending = false;
3692
3693	switch (mState) {
3694	case READING:
3695	MOZ_ASSERT(mIndexHandle == aHandle \|\| mJournalHandle == aHandle)do { static_assert( mozilla::detail::AssertionConditionType< decltype(mIndexHandle == aHandle \|\| mJournalHandle == aHandle )>::isValid, "invalid assertion condition"); if ((__builtin_expect (!!(!(!!(mIndexHandle == aHandle \|\| mJournalHandle == aHandle ))), 0))) { do { } while (false); MOZ_ReportAssertionFailure( "mIndexHandle == aHandle \|\| mJournalHandle == aHandle", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3695); AnnotateMozCrashReason("MOZ_ASSERT" "(" "mIndexHandle == aHandle \|\| mJournalHandle == aHandle" ")"); do { ((volatile int)__null) = 3695; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3696
3697	if (NS_FAILED(aResult)((bool)(__builtin_expect(!!(NS_FAILED_impl(aResult)), 0)))) {
3698	FinishRead(false, lock);
3699	} else {
3700	if (!mIndexOnDiskIsValid) {
3701	ParseRecords(lock);
3702	} else {
3703	ParseJournal(lock);
3704	}
3705	}
3706	break;
3707	default:
3708	// Reading was canceled.
3709	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3710	("CacheIndex::OnDataRead() - ignoring notification since the "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3711	"operation was previously canceled [state=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3712	mState))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnDataRead() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0);
3713	ReleaseBuffer();
3714	}
3715
3716	return NS_OK;
3717	}
3718
3719	nsresult CacheIndex::OnFileDoomed(CacheFileHandle* aHandle, nsresult aResult) {
3720	MOZ_CRASH("CacheIndex::OnFileDoomed should not be called!")do { do { } while (false); MOZ_ReportCrash("" "CacheIndex::OnFileDoomed should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3720); AnnotateMozCrashReason("MOZ_CRASH(" "CacheIndex::OnFileDoomed should not be called!" ")"); do { ((volatile int)__null) = 3720; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
3721	return NS_ERROR_UNEXPECTED;
3722	}
3723
3724	nsresult CacheIndex::OnEOFSet(CacheFileHandle* aHandle, nsresult aResult) {
3725	MOZ_CRASH("CacheIndex::OnEOFSet should not be called!")do { do { } while (false); MOZ_ReportCrash("" "CacheIndex::OnEOFSet should not be called!" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3725); AnnotateMozCrashReason("MOZ_CRASH(" "CacheIndex::OnEOFSet should not be called!" ")"); do { ((volatile int)__null) = 3725; __attribute__((nomerge )) ::abort(); } while (false); } while (false);
3726	return NS_ERROR_UNEXPECTED;
3727	}
3728
3729	nsresult CacheIndex::OnFileRenamed(CacheFileHandle* aHandle, nsresult aResult) {
3730	LOG(("CacheIndex::OnFileRenamed() [handle=%p, result=0x%08" PRIx32 "]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0)
3731	aHandle, static_cast<uint32_t>(aResult)))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() [handle=%p, result=0x%08" "x" "]", aHandle, static_cast<uint32_t>(aResult)); } } while (0);
3732
3733	MOZ_ASSERT(CacheFileIOManager::IsOnIOThread())do { static_assert( mozilla::detail::AssertionConditionType< decltype(CacheFileIOManager::IsOnIOThread())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(CacheFileIOManager::IsOnIOThread ()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure ("CacheFileIOManager::IsOnIOThread()", "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3733); AnnotateMozCrashReason("MOZ_ASSERT" "(" "CacheFileIOManager::IsOnIOThread()" ")"); do { ((volatile int)__null) = 3733; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3734
3735	StaticMutexAutoLock lock(sLock);
3736
3737	MOZ_RELEASE_ASSERT(IsIndexUsable())do { static_assert( mozilla::detail::AssertionConditionType< decltype(IsIndexUsable())>::isValid, "invalid assertion condition" ); if ((__builtin_expect(!!(!(!!(IsIndexUsable()))), 0))) { do { } while (false); MOZ_ReportAssertionFailure("IsIndexUsable()" , "/var/lib/jenkins/workspace/firefox-scan-build/netwerk/cache2/CacheIndex.cpp" , 3737); AnnotateMozCrashReason("MOZ_RELEASE_ASSERT" "(" "IsIndexUsable()" ")"); do { ((volatile int)__null) = 3737; __attribute__((nomerge )) ::abort(); } while (false); } } while (false);
3738
3739	if (mState == READY && mShuttingDown) {
3740	return NS_OK;
3741	}
3742
3743	switch (mState) {
3744	case WRITING:
3745	// This is a result of renaming the new index written to tmpfile to index
3746	// file. This is the last step when writing the index and the whole
3747	// writing process is successful iff renaming was successful.
3748
3749	if (mIndexHandle != aHandle) {
3750	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3751	("CacheIndex::OnFileRenamed() - ignoring notification since it "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3752	"belongs to previously canceled operation [state=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3753	mState))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0);
3754	break;
3755	}
3756
3757	FinishWrite(NS_SUCCEEDED(aResult)((bool)(__builtin_expect(!!(!NS_FAILED_impl(aResult)), 1))), lock);
3758	break;
3759	case READING:
3760	// This is a result of renaming journal file to tmpfile. It is renamed
3761	// before we start reading index and journal file and it should normally
3762	// succeed. If it fails give up reading of index.
3763
3764	if (mJournalHandle != aHandle) {
3765	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3766	("CacheIndex::OnFileRenamed() - ignoring notification since it "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3767	"belongs to previously canceled operation [state=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0)
3768	mState))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since it " "belongs to previously canceled operation [state=%d]", mState ); } } while (0);
3769	break;
3770	}
3771
3772	if (NS_FAILED(aResult)((bool)(__builtin_expect(!!(NS_FAILED_impl(aResult)), 0)))) {
3773	FinishRead(false, lock);
3774	} else {
3775	StartReadingIndex(lock);
3776	}
3777	break;
3778	default:
3779	// Reading/writing was canceled.
3780	LOG(do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3781	("CacheIndex::OnFileRenamed() - ignoring notification since the "do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3782	"operation was previously canceled [state=%d]",do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0)
3783	mState))do { const ::mozilla::LogModule* moz_real_module = gCache2Log ; if ((__builtin_expect(!!(mozilla::detail::log_test(moz_real_module , mozilla::LogLevel::Debug)), 0))) { mozilla::detail::log_print (moz_real_module, mozilla::LogLevel::Debug, "CacheIndex::OnFileRenamed() - ignoring notification since the " "operation was previously canceled [state=%d]", mState); } } while (0);
3784	}
3785
3786	return NS_OK;
3787	}
3788
3789	// Memory reporting
3790
3791	size_t CacheIndex::SizeOfExcludingThisInternal(
3792	mozilla::MallocSizeOf mallocSizeOf) const {
3793	sLock.AssertCurrentThreadOwns();
3794
3795	size_t n = 0;
3796	nsCOMPtr<nsISizeOf> sizeOf;
3797
3798	// mIndexHandle and mJournalHandle are reported via SizeOfHandlesRunnable
3799	// in CacheFileIOManager::SizeOfExcludingThisInternal as part of special
3800	// handles array.
3801
3802	sizeOf = do_QueryInterface(mCacheDirectory);
3803	if (sizeOf) {
3804	n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
3805	}
3806
3807	sizeOf = do_QueryInterface(mUpdateTimer);
3808	if (sizeOf) {
3809	n += sizeOf->SizeOfIncludingThis(mallocSizeOf);
3810	}
3811
3812	n += mallocSizeOf(mRWBuf);
3813	n += mallocSizeOf(mRWHash);
3814
3815	n += mIndex.SizeOfExcludingThis(mallocSizeOf);
3816	n += mPendingUpdates.SizeOfExcludingThis(mallocSizeOf);
3817	n += mTmpJournal.SizeOfExcludingThis(mallocSizeOf);
3818
3819	// mFrecencyArray items are reported by mIndex/mPendingUpdates
3820	n += mFrecencyArray.mRecs.ShallowSizeOfExcludingThis(mallocSizeOf);
3821	n += mDiskConsumptionObservers.ShallowSizeOfExcludingThis(mallocSizeOf);
3822
3823	return n;
3824	}
3825
3826	// static
3827	size_t CacheIndex::SizeOfExcludingThis(mozilla::MallocSizeOf mallocSizeOf) {
3828	StaticMutexAutoLock lock(sLock);
3829
3830	if (!gInstance) return 0;
3831
3832	return gInstance->SizeOfExcludingThisInternal(mallocSizeOf);
3833	}
3834
3835	// static
3836	size_t CacheIndex::SizeOfIncludingThis(mozilla::MallocSizeOf mallocSizeOf) {
3837	StaticMutexAutoLock lock(sLock);
3838
3839	return mallocSizeOf(gInstance) +
3840	(gInstance ? gInstance->SizeOfExcludingThisInternal(mallocSizeOf) : 0);
3841	}
3842
3843	// static
3844	void CacheIndex::UpdateTotalBytesWritten(uint32_t aBytesWritten) {
3845	StaticMutexAutoLock lock(sLock);
3846
3847	RefPtr<CacheIndex> index = gInstance;
3848	if (!index) {
3849	return;
3850	}
3851
3852	index->mTotalBytesWritten += aBytesWritten;
3853
3854	// Do telemetry report if enough data has been written and the index is
3855	// in READY state. The data is available also in WRITING state, but we would
3856	// need to deal with pending updates.
3857	if (index->mTotalBytesWritten >= kTelemetryReportBytesLimit(2U * 1024U * 1024U * 1024U) &&
3858	index->mState == READY && !index->mIndexNeedsUpdate &&
3859	!index->mShuttingDown) {
3860	index->DoTelemetryReport();
3861	index->mTotalBytesWritten = 0;
3862	return;
3863	}
3864	}
3865
3866	void CacheIndex::DoTelemetryReport() {
3867	static const nsLiteralCString
3868	contentTypeNames[nsICacheEntry::CONTENT_TYPE_LAST] = {
3869	"UNKNOWN"_ns, "OTHER"_ns, "JAVASCRIPT"_ns, "IMAGE"_ns,
3870	"MEDIA"_ns, "STYLESHEET"_ns, "WASM"_ns};
3871
3872	for (uint32_t i = 0; i < nsICacheEntry::CONTENT_TYPE_LAST; ++i) {
3873	if (mIndexStats.Size() > 0) {
3874	Telemetry::Accumulate(
3875	Telemetry::NETWORK_CACHE_SIZE_SHARE, contentTypeNames[i],
3876	round(static_cast<double>(mIndexStats.SizeByType(i)) * 100.0 /
3877	static_cast<double>(mIndexStats.Size())));
3878	}
3879
3880	if (mIndexStats.Count() > 0) {
3881	Telemetry::Accumulate(
3882	Telemetry::NETWORK_CACHE_ENTRY_COUNT_SHARE, contentTypeNames[i],
3883	round(static_cast<double>(mIndexStats.CountByType(i)) * 100.0 /
3884	static_cast<double>(mIndexStats.Count())));
3885	}
3886	}
3887
3888	nsCString probeKey;
3889	if (CacheObserver::SmartCacheSizeEnabled()) {
3890	probeKey = "SMARTSIZE"_ns;
3891	} else {
3892	probeKey = "USERDEFINEDSIZE"_ns;
3893	}
3894	Telemetry::Accumulate(Telemetry::NETWORK_CACHE_ENTRY_COUNT, probeKey,
3895	mIndexStats.Count());
3896	Telemetry::Accumulate(Telemetry::NETWORK_CACHE_SIZE, probeKey,
3897	mIndexStats.Size() >> 10);
3898	}
3899
3900	// static
3901	void CacheIndex::OnAsyncEviction(bool aEvicting) {
3902	StaticMutexAutoLock lock(sLock);
3903
3904	RefPtr<CacheIndex> index = gInstance;
3905	if (!index) {
3906	return;
3907	}
3908
3909	index->mAsyncGetDiskConsumptionBlocked = aEvicting;
3910	if (!aEvicting) {
3911	index->NotifyAsyncGetDiskConsumptionCallbacks();
3912	}
3913	}
3914
3915	} // namespace mozilla::net