void BitCache::AsyncReadBlock(std::size_t piece_index,
std::size_t begin_of_piece,
std::size_t length,
const ReadCallback& callback)
{
AsyncReadOps::iterator it = async_read_ops_.find(piece_index);
if (it == async_read_ops_.end())
file_.ReadPiece(piece_index, FetchNewPiece());
async_read_ops_.insert(it,
std::make_pair(piece_index,
AsyncReadData(callback, begin_of_piece, length)));
}
nsresult
DataStorage::Init(bool& aDataWillPersist)
{
// Don't access the observer service or preferences off the main thread.
if (!NS_IsMainThread()) {
NS_NOTREACHED("DataStorage::Init called off main thread");
return NS_ERROR_NOT_SAME_THREAD;
}
MutexAutoLock lock(mMutex);
nsresult rv;
rv = NS_NewThread(getter_AddRefs(mWorkerThread));
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
rv = AsyncReadData(aDataWillPersist, lock);
if (NS_FAILED(rv)) {
return rv;
}
nsCOMPtr<nsIObserverService> os = services::GetObserverService();
if (NS_WARN_IF(!os)) {
return NS_ERROR_FAILURE;
}
// Clear private data as appropriate.
os->AddObserver(this, "last-pb-context-exited", false);
// Observe shutdown; save data and prevent any further writes.
os->AddObserver(this, "profile-before-change", false);
// For test purposes, we can set the write timer to be very fast.
mTimerDelay = Preferences::GetInt("test.datastorage.write_timer_ms",
sDataStorageDefaultTimerDelay);
rv = Preferences::AddStrongObserver(this, "test.datastorage.write_timer_ms");
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
void TcpConnect::HandleReadData(const boost::system::error_code& err, int read_size){
if (state_ == CS_CLOSED){
return;
}
if (err){
//LOG(ERROR) << err.message();
return ConnectError(err);
}
read_buffer_->WriteBytes(pre_read_buffer_, read_size);
// -------------------------------------------------------------------------
while (read_buffer_->Length() >= HEADER_BUFFERR_SIZE){
memcpy(read_header_buffer_, read_buffer_->Data(), HEADER_BUFFERR_SIZE);
if (read_header_buffer_[0] != VZ_HEADER[0] || read_header_buffer_[1] != VZ_HEADER[1]){
//LOG(ERROR) << "The packet header VZ getting error";
return ConnectError(boost::asio::error::invalid_argument);
}
uint16 flag = *((uint16*)(read_header_buffer_ + 2));
uint32 packet_size = *(uint32*)(read_header_buffer_ + 4);
flag = ntohs(flag);
packet_size = ntohl(packet_size);
if (packet_size > MAX_PKT_SIZE){
//LOG(ERROR) << "The packet size large than " << MAX_PKT_SIZE;
return ConnectError(boost::asio::error::invalid_argument);
}
if (packet_size <= (read_buffer_->Length() - HEADER_BUFFERR_SIZE)){
SignalConnectRead(shared_from_this(),
read_buffer_->Data() + HEADER_BUFFERR_SIZE, packet_size, flag);
read_buffer_->Consume(packet_size + HEADER_BUFFERR_SIZE);
}
else{
break;
}
}
AsyncReadData();
}
