| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "net/tools/dump_cache/upgrade_win.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "base/bind_helpers.h" | |
| 9 #include "base/logging.h" | |
| 10 #include "base/memory/scoped_ptr.h" | |
| 11 #include "base/message_loop/message_loop.h" | |
| 12 #include "base/strings/string_number_conversions.h" | |
| 13 #include "base/strings/string_util.h" | |
| 14 #include "base/threading/thread.h" | |
| 15 #include "base/win/scoped_handle.h" | |
| 16 #include "net/base/cache_type.h" | |
| 17 #include "net/base/io_buffer.h" | |
| 18 #include "net/base/net_errors.h" | |
| 19 #include "net/base/test_completion_callback.h" | |
| 20 #include "net/disk_cache/blockfile/backend_impl.h" | |
| 21 #include "net/disk_cache/blockfile/entry_impl.h" | |
| 22 #include "net/http/http_cache.h" | |
| 23 #include "net/http/http_response_headers.h" | |
| 24 #include "net/http/http_response_info.h" | |
| 25 #include "net/tools/dump_cache/cache_dumper.h" | |
| 26 #include "url/gurl.h" | |
| 27 | |
| 28 namespace { | |
| 29 | |
| 30 const wchar_t kPipePrefix[] = L"\\\\.\\pipe\\dump_cache_"; | |
| 31 const int kChannelSize = 64 * 1024; | |
| 32 const int kNumStreams = 4; | |
| 33 | |
| 34 // Simple macro to print out formatted debug messages. It is similar to a DLOG | |
| 35 // except that it doesn't include a header. | |
| 36 #ifdef NDEBUG | |
| 37 #define DEBUGMSG(...) {} | |
| 38 #else | |
| 39 #define DEBUGMSG(...) { printf(__VA_ARGS__); } | |
| 40 #endif | |
| 41 | |
| 42 HANDLE OpenServer(const base::string16& pipe_number) { | |
| 43 base::string16 pipe_name(kPipePrefix); | |
| 44 pipe_name.append(pipe_number); | |
| 45 return CreateFile(pipe_name.c_str(), GENERIC_READ | GENERIC_WRITE, 0, NULL, | |
| 46 OPEN_EXISTING, FILE_FLAG_OVERLAPPED, NULL); | |
| 47 } | |
| 48 | |
| 49 // This is the basic message to use between the two processes. It is intended | |
| 50 // to transmit a single action (like "get the key name for entry xx"), with up | |
| 51 // to 5 32-bit arguments and 4 64-bit arguments. After this structure, the rest | |
| 52 // of the message has |buffer_bytes| of length with the actual data. | |
| 53 struct Message { | |
| 54 int32 command; | |
| 55 int32 result; | |
| 56 int32 buffer_bytes; | |
| 57 int32 arg1; | |
| 58 int32 arg2; | |
| 59 int32 arg3; | |
| 60 int32 arg4; | |
| 61 int32 arg5; | |
| 62 int64 long_arg1; | |
| 63 int64 long_arg2; | |
| 64 int64 long_arg3; | |
| 65 int64 long_arg4; | |
| 66 Message() { | |
| 67 memset(this, 0, sizeof(*this)); | |
| 68 } | |
| 69 Message& operator= (const Message& other) { | |
| 70 memcpy(this, &other, sizeof(*this)); | |
| 71 return *this; | |
| 72 } | |
| 73 }; | |
| 74 | |
| 75 const int kBufferSize = kChannelSize - sizeof(Message); | |
| 76 struct IoBuffer { | |
| 77 Message msg; | |
| 78 char buffer[kBufferSize]; | |
| 79 }; | |
| 80 COMPILE_ASSERT(sizeof(IoBuffer) == kChannelSize, invalid_io_buffer); | |
| 81 | |
| 82 | |
| 83 // The list of commands. | |
| 84 // Currently, there is support for working ONLY with one entry at a time. | |
| 85 enum { | |
| 86 // Get the entry from list |arg1| that follows |long_arg1|. | |
| 87 // The result is placed on |long_arg1| (closes the previous one). | |
| 88 GET_NEXT_ENTRY = 1, | |
| 89 // Get the entry from list |arg1| that precedes |long_arg1|. | |
| 90 // The result is placed on |long_arg1| (closes the previous one). | |
| 91 GET_PREV_ENTRY, | |
| 92 // Closes the entry |long_arg1|. | |
| 93 CLOSE_ENTRY, | |
| 94 // Get the key of the entry |long_arg1|. | |
| 95 GET_KEY, | |
| 96 // Get last used (long_arg2) and last modified (long_arg3) times for the | |
| 97 // entry at |long_arg1|. | |
| 98 GET_USE_TIMES, | |
| 99 // Returns on |arg2| the data size in bytes if the stream |arg1| of entry at | |
| 100 // |long_arg1|. | |
| 101 GET_DATA_SIZE, | |
| 102 // Returns |arg2| bytes of the stream |arg1| for the entry at |long_arg1|, | |
| 103 // starting at offset |arg3|. | |
| 104 READ_DATA, | |
| 105 // End processing requests. | |
| 106 QUIT | |
| 107 }; | |
| 108 | |
| 109 // The list of return codes. | |
| 110 enum { | |
| 111 RESULT_OK = 0, | |
| 112 RESULT_UNKNOWN_COMMAND, | |
| 113 RESULT_INVALID_PARAMETER, | |
| 114 RESULT_NAME_OVERFLOW, | |
| 115 RESULT_PENDING // This error code is NOT expected by the master process. | |
| 116 }; | |
| 117 | |
| 118 // ----------------------------------------------------------------------- | |
| 119 | |
| 120 class BaseSM : public base::MessageLoopForIO::IOHandler { | |
| 121 public: | |
| 122 explicit BaseSM(HANDLE channel); | |
| 123 virtual ~BaseSM(); | |
| 124 | |
| 125 protected: | |
| 126 bool SendMsg(const Message& msg); | |
| 127 bool ReceiveMsg(); | |
| 128 bool ConnectChannel(); | |
| 129 bool IsPending(); | |
| 130 | |
| 131 base::MessageLoopForIO::IOContext in_context_; | |
| 132 base::MessageLoopForIO::IOContext out_context_; | |
| 133 disk_cache::EntryImpl* entry_; | |
| 134 HANDLE channel_; | |
| 135 int state_; | |
| 136 int pending_count_; | |
| 137 scoped_ptr<char[]> in_buffer_; | |
| 138 scoped_ptr<char[]> out_buffer_; | |
| 139 IoBuffer* input_; | |
| 140 IoBuffer* output_; | |
| 141 base::Thread cache_thread_; | |
| 142 | |
| 143 DISALLOW_COPY_AND_ASSIGN(BaseSM); | |
| 144 }; | |
| 145 | |
| 146 BaseSM::BaseSM(HANDLE channel) | |
| 147 : entry_(NULL), channel_(channel), state_(0), pending_count_(0), | |
| 148 cache_thread_("cache") { | |
| 149 in_buffer_.reset(new char[kChannelSize]); | |
| 150 out_buffer_.reset(new char[kChannelSize]); | |
| 151 input_ = reinterpret_cast<IoBuffer*>(in_buffer_.get()); | |
| 152 output_ = reinterpret_cast<IoBuffer*>(out_buffer_.get()); | |
| 153 | |
| 154 memset(&in_context_, 0, sizeof(in_context_)); | |
| 155 memset(&out_context_, 0, sizeof(out_context_)); | |
| 156 in_context_.handler = this; | |
| 157 out_context_.handler = this; | |
| 158 base::MessageLoopForIO::current()->RegisterIOHandler(channel_, this); | |
| 159 CHECK(cache_thread_.StartWithOptions( | |
| 160 base::Thread::Options(base::MessageLoop::TYPE_IO, 0))); | |
| 161 } | |
| 162 | |
| 163 BaseSM::~BaseSM() { | |
| 164 if (entry_) | |
| 165 entry_->Close(); | |
| 166 } | |
| 167 | |
| 168 bool BaseSM::SendMsg(const Message& msg) { | |
| 169 // Only one command will be in-flight at a time. Let's start the Read IO here | |
| 170 // when we know that it will be pending. | |
| 171 if (!ReceiveMsg()) | |
| 172 return false; | |
| 173 | |
| 174 output_->msg = msg; | |
| 175 DWORD written; | |
| 176 if (!WriteFile(channel_, output_, sizeof(msg) + msg.buffer_bytes, &written, | |
| 177 &out_context_.overlapped)) { | |
| 178 if (ERROR_IO_PENDING != GetLastError()) | |
| 179 return false; | |
| 180 } | |
| 181 pending_count_++; | |
| 182 return true; | |
| 183 } | |
| 184 | |
| 185 bool BaseSM::ReceiveMsg() { | |
| 186 DWORD read; | |
| 187 if (!ReadFile(channel_, input_, kChannelSize, &read, | |
| 188 &in_context_.overlapped)) { | |
| 189 if (ERROR_IO_PENDING != GetLastError()) | |
| 190 return false; | |
| 191 } | |
| 192 pending_count_++; | |
| 193 return true; | |
| 194 } | |
| 195 | |
| 196 bool BaseSM::ConnectChannel() { | |
| 197 if (!ConnectNamedPipe(channel_, &in_context_.overlapped)) { | |
| 198 DWORD error = GetLastError(); | |
| 199 if (ERROR_PIPE_CONNECTED == error) | |
| 200 return true; | |
| 201 // By returning true in case of a generic error, we allow the operation to | |
| 202 // fail while sending the first message. | |
| 203 if (ERROR_IO_PENDING != error) | |
| 204 return true; | |
| 205 } | |
| 206 pending_count_++; | |
| 207 return false; | |
| 208 } | |
| 209 | |
| 210 bool BaseSM::IsPending() { | |
| 211 return pending_count_ != 0; | |
| 212 } | |
| 213 | |
| 214 // ----------------------------------------------------------------------- | |
| 215 | |
| 216 class MasterSM : public BaseSM { | |
| 217 public: | |
| 218 MasterSM(const base::FilePath& path, HANDLE channel) | |
| 219 : BaseSM(channel), | |
| 220 path_(path) { | |
| 221 } | |
| 222 virtual ~MasterSM() { | |
| 223 delete writer_; | |
| 224 } | |
| 225 | |
| 226 bool DoInit(); | |
| 227 virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context, | |
| 228 DWORD bytes_transfered, | |
| 229 DWORD error); | |
| 230 | |
| 231 private: | |
| 232 enum { | |
| 233 MASTER_INITIAL = 0, | |
| 234 MASTER_CONNECT, | |
| 235 MASTER_GET_ENTRY, | |
| 236 MASTER_GET_NEXT_ENTRY, | |
| 237 MASTER_GET_KEY, | |
| 238 MASTER_GET_USE_TIMES, | |
| 239 MASTER_GET_DATA_SIZE, | |
| 240 MASTER_READ_DATA, | |
| 241 MASTER_END | |
| 242 }; | |
| 243 | |
| 244 void SendGetPrevEntry(); | |
| 245 void DoGetEntry(); | |
| 246 void DoGetKey(int bytes_read); | |
| 247 void DoCreateEntryComplete(int result); | |
| 248 void DoGetUseTimes(); | |
| 249 void SendGetDataSize(); | |
| 250 void DoGetDataSize(); | |
| 251 void CloseEntry(); | |
| 252 void SendReadData(); | |
| 253 void DoReadData(int bytes_read); | |
| 254 void DoReadDataComplete(int ret); | |
| 255 void SendQuit(); | |
| 256 void DoEnd(); | |
| 257 void Fail(); | |
| 258 | |
| 259 base::Time last_used_; | |
| 260 base::Time last_modified_; | |
| 261 int64 remote_entry_; | |
| 262 int stream_; | |
| 263 int bytes_remaining_; | |
| 264 int offset_; | |
| 265 int copied_entries_; | |
| 266 int read_size_; | |
| 267 scoped_ptr<disk_cache::Backend> cache_; | |
| 268 CacheDumpWriter* writer_; | |
| 269 const base::FilePath path_; | |
| 270 }; | |
| 271 | |
| 272 void MasterSM::OnIOCompleted(base::MessageLoopForIO::IOContext* context, | |
| 273 DWORD bytes_transfered, | |
| 274 DWORD error) { | |
| 275 pending_count_--; | |
| 276 if (context == &out_context_) { | |
| 277 if (!error) | |
| 278 return; | |
| 279 return Fail(); | |
| 280 } | |
| 281 | |
| 282 int bytes_read = static_cast<int>(bytes_transfered); | |
| 283 if (bytes_read < sizeof(Message) && state_ != MASTER_END && | |
| 284 state_ != MASTER_CONNECT) { | |
| 285 printf("Communication breakdown\n"); | |
| 286 return Fail(); | |
| 287 } | |
| 288 | |
| 289 switch (state_) { | |
| 290 case MASTER_CONNECT: | |
| 291 SendGetPrevEntry(); | |
| 292 break; | |
| 293 case MASTER_GET_ENTRY: | |
| 294 DoGetEntry(); | |
| 295 break; | |
| 296 case MASTER_GET_KEY: | |
| 297 DoGetKey(bytes_read); | |
| 298 break; | |
| 299 case MASTER_GET_USE_TIMES: | |
| 300 DoGetUseTimes(); | |
| 301 break; | |
| 302 case MASTER_GET_DATA_SIZE: | |
| 303 DoGetDataSize(); | |
| 304 break; | |
| 305 case MASTER_READ_DATA: | |
| 306 DoReadData(bytes_read); | |
| 307 break; | |
| 308 case MASTER_END: | |
| 309 if (!IsPending()) | |
| 310 DoEnd(); | |
| 311 break; | |
| 312 default: | |
| 313 NOTREACHED(); | |
| 314 break; | |
| 315 } | |
| 316 } | |
| 317 | |
| 318 bool MasterSM::DoInit() { | |
| 319 DEBUGMSG("Master DoInit\n"); | |
| 320 DCHECK(state_ == MASTER_INITIAL); | |
| 321 | |
| 322 scoped_ptr<disk_cache::Backend> cache; | |
| 323 net::TestCompletionCallback cb; | |
| 324 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, | |
| 325 net::CACHE_BACKEND_DEFAULT, path_, 0, | |
| 326 false, | |
| 327 cache_thread_.message_loop_proxy(), | |
| 328 NULL, &cache, cb.callback()); | |
| 329 if (cb.GetResult(rv) != net::OK) { | |
| 330 printf("Unable to initialize new files\n"); | |
| 331 return false; | |
| 332 } | |
| 333 cache_ = cache.Pass(); | |
| 334 writer_ = new CacheDumper(cache_.get()); | |
| 335 | |
| 336 copied_entries_ = 0; | |
| 337 remote_entry_ = 0; | |
| 338 | |
| 339 if (ConnectChannel()) { | |
| 340 SendGetPrevEntry(); | |
| 341 // If we don't have pending operations we couldn't connect. | |
| 342 return IsPending(); | |
| 343 } | |
| 344 | |
| 345 state_ = MASTER_CONNECT; | |
| 346 return true; | |
| 347 } | |
| 348 | |
| 349 void MasterSM::SendGetPrevEntry() { | |
| 350 DEBUGMSG("Master SendGetPrevEntry\n"); | |
| 351 state_ = MASTER_GET_ENTRY; | |
| 352 Message msg; | |
| 353 msg.command = GET_PREV_ENTRY; | |
| 354 msg.long_arg1 = remote_entry_; | |
| 355 SendMsg(msg); | |
| 356 } | |
| 357 | |
| 358 void MasterSM::DoGetEntry() { | |
| 359 DEBUGMSG("Master DoGetEntry\n"); | |
| 360 DCHECK(state_ == MASTER_GET_ENTRY); | |
| 361 DCHECK(input_->msg.command == GET_PREV_ENTRY); | |
| 362 if (input_->msg.result != RESULT_OK) | |
| 363 return Fail(); | |
| 364 | |
| 365 if (!input_->msg.long_arg1) { | |
| 366 printf("Done: %d entries copied over.\n", copied_entries_); | |
| 367 return SendQuit(); | |
| 368 } | |
| 369 remote_entry_ = input_->msg.long_arg1; | |
| 370 state_ = MASTER_GET_KEY; | |
| 371 Message msg; | |
| 372 msg.command = GET_KEY; | |
| 373 msg.long_arg1 = remote_entry_; | |
| 374 SendMsg(msg); | |
| 375 } | |
| 376 | |
| 377 void MasterSM::DoGetKey(int bytes_read) { | |
| 378 DEBUGMSG("Master DoGetKey\n"); | |
| 379 DCHECK(state_ == MASTER_GET_KEY); | |
| 380 DCHECK(input_->msg.command == GET_KEY); | |
| 381 if (input_->msg.result == RESULT_NAME_OVERFLOW) { | |
| 382 // The key is too long. Just move on. | |
| 383 printf("Skipping entry (name too long)\n"); | |
| 384 return SendGetPrevEntry(); | |
| 385 } | |
| 386 | |
| 387 if (input_->msg.result != RESULT_OK) | |
| 388 return Fail(); | |
| 389 | |
| 390 std::string key(input_->buffer); | |
| 391 DCHECK(key.size() == static_cast<size_t>(input_->msg.buffer_bytes - 1)); | |
| 392 | |
| 393 int rv = writer_->CreateEntry( | |
| 394 key, reinterpret_cast<disk_cache::Entry**>(&entry_), | |
| 395 base::Bind(&MasterSM::DoCreateEntryComplete, base::Unretained(this))); | |
| 396 | |
| 397 if (rv != net::ERR_IO_PENDING) | |
| 398 DoCreateEntryComplete(rv); | |
| 399 } | |
| 400 | |
| 401 void MasterSM::DoCreateEntryComplete(int result) { | |
| 402 std::string key(input_->buffer); | |
| 403 if (result != net::OK) { | |
| 404 printf("Skipping entry \"%s\": %d\n", key.c_str(), GetLastError()); | |
| 405 return SendGetPrevEntry(); | |
| 406 } | |
| 407 | |
| 408 if (key.size() >= 64) { | |
| 409 key[60] = '.'; | |
| 410 key[61] = '.'; | |
| 411 key[62] = '.'; | |
| 412 key[63] = '\0'; | |
| 413 } | |
| 414 DEBUGMSG("Entry \"%s\" created\n", key.c_str()); | |
| 415 state_ = MASTER_GET_USE_TIMES; | |
| 416 Message msg; | |
| 417 msg.command = GET_USE_TIMES; | |
| 418 msg.long_arg1 = remote_entry_; | |
| 419 SendMsg(msg); | |
| 420 } | |
| 421 | |
| 422 void MasterSM::DoGetUseTimes() { | |
| 423 DEBUGMSG("Master DoGetUseTimes\n"); | |
| 424 DCHECK(state_ == MASTER_GET_USE_TIMES); | |
| 425 DCHECK(input_->msg.command == GET_USE_TIMES); | |
| 426 if (input_->msg.result != RESULT_OK) | |
| 427 return Fail(); | |
| 428 | |
| 429 last_used_ = base::Time::FromInternalValue(input_->msg.long_arg2); | |
| 430 last_modified_ = base::Time::FromInternalValue(input_->msg.long_arg3); | |
| 431 stream_ = 0; | |
| 432 SendGetDataSize(); | |
| 433 } | |
| 434 | |
| 435 void MasterSM::SendGetDataSize() { | |
| 436 DEBUGMSG("Master SendGetDataSize (%d)\n", stream_); | |
| 437 state_ = MASTER_GET_DATA_SIZE; | |
| 438 Message msg; | |
| 439 msg.command = GET_DATA_SIZE; | |
| 440 msg.arg1 = stream_; | |
| 441 msg.long_arg1 = remote_entry_; | |
| 442 SendMsg(msg); | |
| 443 } | |
| 444 | |
| 445 void MasterSM::DoGetDataSize() { | |
| 446 DEBUGMSG("Master DoGetDataSize: %d\n", input_->msg.arg2); | |
| 447 DCHECK(state_ == MASTER_GET_DATA_SIZE); | |
| 448 DCHECK(input_->msg.command == GET_DATA_SIZE); | |
| 449 if (input_->msg.result == RESULT_INVALID_PARAMETER) | |
| 450 // No more streams, move to the next entry. | |
| 451 return CloseEntry(); | |
| 452 | |
| 453 if (input_->msg.result != RESULT_OK) | |
| 454 return Fail(); | |
| 455 | |
| 456 bytes_remaining_ = input_->msg.arg2; | |
| 457 offset_ = 0; | |
| 458 SendReadData(); | |
| 459 } | |
| 460 | |
| 461 void MasterSM::CloseEntry() { | |
| 462 DEBUGMSG("Master CloseEntry\n"); | |
| 463 printf("%c\r", copied_entries_ % 2 ? 'x' : '+'); | |
| 464 writer_->CloseEntry(entry_, last_used_, last_modified_); | |
| 465 entry_ = NULL; | |
| 466 copied_entries_++; | |
| 467 SendGetPrevEntry(); | |
| 468 } | |
| 469 | |
| 470 void MasterSM::SendReadData() { | |
| 471 int read_size = std::min(bytes_remaining_, kBufferSize); | |
| 472 DEBUGMSG("Master SendReadData (%d): %d bytes at %d\n", stream_, read_size, | |
| 473 offset_); | |
| 474 if (bytes_remaining_ <= 0) { | |
| 475 stream_++; | |
| 476 if (stream_ >= kNumStreams) | |
| 477 return CloseEntry(); | |
| 478 return SendGetDataSize(); | |
| 479 } | |
| 480 | |
| 481 state_ = MASTER_READ_DATA; | |
| 482 Message msg; | |
| 483 msg.command = READ_DATA; | |
| 484 msg.arg1 = stream_; | |
| 485 msg.arg2 = read_size; | |
| 486 msg.arg3 = offset_; | |
| 487 msg.long_arg1 = remote_entry_; | |
| 488 SendMsg(msg); | |
| 489 } | |
| 490 | |
| 491 void MasterSM::DoReadData(int bytes_read) { | |
| 492 DEBUGMSG("Master DoReadData: %d bytes\n", input_->msg.buffer_bytes); | |
| 493 DCHECK(state_ == MASTER_READ_DATA); | |
| 494 DCHECK(input_->msg.command == READ_DATA); | |
| 495 if (input_->msg.result != RESULT_OK) | |
| 496 return Fail(); | |
| 497 | |
| 498 int read_size = input_->msg.buffer_bytes; | |
| 499 if (!read_size) { | |
| 500 printf("Read failed, entry \"%s\" truncated!\n", entry_->GetKey().c_str()); | |
| 501 bytes_remaining_ = 0; | |
| 502 return SendReadData(); | |
| 503 } | |
| 504 | |
| 505 scoped_refptr<net::WrappedIOBuffer> buf = | |
| 506 new net::WrappedIOBuffer(input_->buffer); | |
| 507 int rv = writer_->WriteEntry( | |
| 508 entry_, stream_, offset_, buf, read_size, | |
| 509 base::Bind(&MasterSM::DoReadDataComplete, base::Unretained(this))); | |
| 510 if (rv == net::ERR_IO_PENDING) { | |
| 511 // We'll continue in DoReadDataComplete. | |
| 512 read_size_ = read_size; | |
| 513 return; | |
| 514 } | |
| 515 | |
| 516 if (rv <= 0) | |
| 517 return Fail(); | |
| 518 | |
| 519 offset_ += read_size; | |
| 520 bytes_remaining_ -= read_size; | |
| 521 // Read some more. | |
| 522 SendReadData(); | |
| 523 } | |
| 524 | |
| 525 void MasterSM::DoReadDataComplete(int ret) { | |
| 526 if (ret != read_size_) | |
| 527 return Fail(); | |
| 528 | |
| 529 offset_ += ret; | |
| 530 bytes_remaining_ -= ret; | |
| 531 // Read some more. | |
| 532 SendReadData(); | |
| 533 } | |
| 534 | |
| 535 void MasterSM::SendQuit() { | |
| 536 DEBUGMSG("Master SendQuit\n"); | |
| 537 state_ = MASTER_END; | |
| 538 Message msg; | |
| 539 msg.command = QUIT; | |
| 540 SendMsg(msg); | |
| 541 if (!IsPending()) | |
| 542 DoEnd(); | |
| 543 } | |
| 544 | |
| 545 void MasterSM::DoEnd() { | |
| 546 DEBUGMSG("Master DoEnd\n"); | |
| 547 base::MessageLoop::current()->PostTask(FROM_HERE, | |
| 548 base::MessageLoop::QuitClosure()); | |
| 549 } | |
| 550 | |
| 551 void MasterSM::Fail() { | |
| 552 DEBUGMSG("Master Fail\n"); | |
| 553 printf("Unexpected failure\n"); | |
| 554 SendQuit(); | |
| 555 } | |
| 556 | |
| 557 // ----------------------------------------------------------------------- | |
| 558 | |
| 559 class SlaveSM : public BaseSM { | |
| 560 public: | |
| 561 SlaveSM(const base::FilePath& path, HANDLE channel); | |
| 562 virtual ~SlaveSM(); | |
| 563 | |
| 564 bool DoInit(); | |
| 565 virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context, | |
| 566 DWORD bytes_transfered, | |
| 567 DWORD error); | |
| 568 | |
| 569 private: | |
| 570 enum { | |
| 571 SLAVE_INITIAL = 0, | |
| 572 SLAVE_WAITING, | |
| 573 SLAVE_END | |
| 574 }; | |
| 575 | |
| 576 void DoGetNextEntry(); | |
| 577 void DoGetPrevEntry(); | |
| 578 int32 GetEntryFromList(); | |
| 579 void DoGetEntryComplete(int result); | |
| 580 void DoCloseEntry(); | |
| 581 void DoGetKey(); | |
| 582 void DoGetUseTimes(); | |
| 583 void DoGetDataSize(); | |
| 584 void DoReadData(); | |
| 585 void DoReadDataComplete(int ret); | |
| 586 void DoEnd(); | |
| 587 void Fail(); | |
| 588 | |
| 589 void* iterator_; | |
| 590 Message msg_; // Used for DoReadDataComplete and DoGetEntryComplete. | |
| 591 | |
| 592 scoped_ptr<disk_cache::BackendImpl> cache_; | |
| 593 }; | |
| 594 | |
| 595 SlaveSM::SlaveSM(const base::FilePath& path, HANDLE channel) | |
| 596 : BaseSM(channel), iterator_(NULL) { | |
| 597 scoped_ptr<disk_cache::Backend> cache; | |
| 598 net::TestCompletionCallback cb; | |
| 599 int rv = disk_cache::CreateCacheBackend(net::DISK_CACHE, | |
| 600 net::CACHE_BACKEND_BLOCKFILE, path, 0, | |
| 601 false, | |
| 602 cache_thread_.message_loop_proxy(), | |
| 603 NULL, &cache, cb.callback()); | |
| 604 if (cb.GetResult(rv) != net::OK) { | |
| 605 printf("Unable to open cache files\n"); | |
| 606 return; | |
| 607 } | |
| 608 cache_.reset(reinterpret_cast<disk_cache::BackendImpl*>(cache.release())); | |
| 609 cache_->SetUpgradeMode(); | |
| 610 } | |
| 611 | |
| 612 SlaveSM::~SlaveSM() { | |
| 613 if (iterator_) | |
| 614 cache_->EndEnumeration(&iterator_); | |
| 615 } | |
| 616 | |
| 617 void SlaveSM::OnIOCompleted(base::MessageLoopForIO::IOContext* context, | |
| 618 DWORD bytes_transfered, | |
| 619 DWORD error) { | |
| 620 pending_count_--; | |
| 621 if (state_ == SLAVE_END) { | |
| 622 if (IsPending()) | |
| 623 return; | |
| 624 return DoEnd(); | |
| 625 } | |
| 626 | |
| 627 if (context == &out_context_) { | |
| 628 if (!error) | |
| 629 return; | |
| 630 return Fail(); | |
| 631 } | |
| 632 | |
| 633 int bytes_read = static_cast<int>(bytes_transfered); | |
| 634 if (bytes_read < sizeof(Message)) { | |
| 635 printf("Communication breakdown\n"); | |
| 636 return Fail(); | |
| 637 } | |
| 638 DCHECK(state_ == SLAVE_WAITING); | |
| 639 | |
| 640 switch (input_->msg.command) { | |
| 641 case GET_NEXT_ENTRY: | |
| 642 DoGetNextEntry(); | |
| 643 break; | |
| 644 case GET_PREV_ENTRY: | |
| 645 DoGetPrevEntry(); | |
| 646 break; | |
| 647 case CLOSE_ENTRY: | |
| 648 DoCloseEntry(); | |
| 649 break; | |
| 650 case GET_KEY: | |
| 651 DoGetKey(); | |
| 652 break; | |
| 653 case GET_USE_TIMES: | |
| 654 DoGetUseTimes(); | |
| 655 break; | |
| 656 case GET_DATA_SIZE: | |
| 657 DoGetDataSize(); | |
| 658 break; | |
| 659 case READ_DATA: | |
| 660 DoReadData(); | |
| 661 break; | |
| 662 case QUIT: | |
| 663 DoEnd(); | |
| 664 break; | |
| 665 default: | |
| 666 NOTREACHED(); | |
| 667 break; | |
| 668 } | |
| 669 } | |
| 670 | |
| 671 bool SlaveSM::DoInit() { | |
| 672 DEBUGMSG("\t\t\tSlave DoInit\n"); | |
| 673 DCHECK(state_ == SLAVE_INITIAL); | |
| 674 state_ = SLAVE_WAITING; | |
| 675 if (!cache_.get()) | |
| 676 return false; | |
| 677 | |
| 678 return ReceiveMsg(); | |
| 679 } | |
| 680 | |
| 681 void SlaveSM::DoGetNextEntry() { | |
| 682 DEBUGMSG("\t\t\tSlave DoGetNextEntry\n"); | |
| 683 Message msg; | |
| 684 msg.command = GET_NEXT_ENTRY; | |
| 685 | |
| 686 if (input_->msg.arg1) { | |
| 687 // We only support one list. | |
| 688 msg.result = RESULT_UNKNOWN_COMMAND; | |
| 689 } else { | |
| 690 msg.result = GetEntryFromList(); | |
| 691 msg.long_arg1 = reinterpret_cast<int64>(entry_); | |
| 692 } | |
| 693 SendMsg(msg); | |
| 694 } | |
| 695 | |
| 696 void SlaveSM::DoGetPrevEntry() { | |
| 697 DEBUGMSG("\t\t\tSlave DoGetPrevEntry\n"); | |
| 698 Message msg; | |
| 699 msg.command = GET_PREV_ENTRY; | |
| 700 | |
| 701 if (input_->msg.arg1) { | |
| 702 // We only support one list. | |
| 703 msg.result = RESULT_UNKNOWN_COMMAND; | |
| 704 } else { | |
| 705 msg.result = GetEntryFromList(); | |
| 706 if (msg.result == RESULT_PENDING) { | |
| 707 // We are not done yet. | |
| 708 msg_ = msg; | |
| 709 return; | |
| 710 } | |
| 711 msg.long_arg1 = reinterpret_cast<int64>(entry_); | |
| 712 } | |
| 713 SendMsg(msg); | |
| 714 } | |
| 715 | |
| 716 // Move to the next or previous entry on the list. | |
| 717 int32 SlaveSM::GetEntryFromList() { | |
| 718 DEBUGMSG("\t\t\tSlave GetEntryFromList\n"); | |
| 719 if (input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) | |
| 720 return RESULT_INVALID_PARAMETER; | |
| 721 | |
| 722 // We know that the current iteration is valid. | |
| 723 if (entry_) | |
| 724 entry_->Close(); | |
| 725 | |
| 726 int rv; | |
| 727 if (input_->msg.command == GET_NEXT_ENTRY) { | |
| 728 rv = cache_->OpenNextEntry( | |
| 729 &iterator_, reinterpret_cast<disk_cache::Entry**>(&entry_), | |
| 730 base::Bind(&SlaveSM::DoGetEntryComplete, base::Unretained(this))); | |
| 731 } else { | |
| 732 DCHECK(input_->msg.command == GET_PREV_ENTRY); | |
| 733 rv = cache_->OpenPrevEntry(&iterator_, | |
| 734 reinterpret_cast<disk_cache::Entry**>(&entry_), | |
| 735 base::Bind(&SlaveSM::DoGetEntryComplete, | |
| 736 base::Unretained(this))); | |
| 737 } | |
| 738 DCHECK_EQ(net::ERR_IO_PENDING, rv); | |
| 739 return RESULT_PENDING; | |
| 740 } | |
| 741 | |
| 742 void SlaveSM::DoGetEntryComplete(int result) { | |
| 743 DEBUGMSG("\t\t\tSlave DoGetEntryComplete\n"); | |
| 744 if (result != net::OK) { | |
| 745 entry_ = NULL; | |
| 746 DEBUGMSG("\t\t\tSlave end of list\n"); | |
| 747 } | |
| 748 | |
| 749 msg_.result = RESULT_OK; | |
| 750 msg_.long_arg1 = reinterpret_cast<int64>(entry_); | |
| 751 SendMsg(msg_); | |
| 752 } | |
| 753 | |
| 754 void SlaveSM::DoCloseEntry() { | |
| 755 DEBUGMSG("\t\t\tSlave DoCloseEntry\n"); | |
| 756 Message msg; | |
| 757 msg.command = GET_KEY; | |
| 758 | |
| 759 if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) { | |
| 760 msg.result = RESULT_INVALID_PARAMETER; | |
| 761 } else { | |
| 762 entry_->Close(); | |
| 763 entry_ = NULL; | |
| 764 cache_->EndEnumeration(&iterator_); | |
| 765 msg.result = RESULT_OK; | |
| 766 } | |
| 767 SendMsg(msg); | |
| 768 } | |
| 769 | |
| 770 void SlaveSM::DoGetKey() { | |
| 771 DEBUGMSG("\t\t\tSlave DoGetKey\n"); | |
| 772 Message msg; | |
| 773 msg.command = GET_KEY; | |
| 774 | |
| 775 if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) { | |
| 776 msg.result = RESULT_INVALID_PARAMETER; | |
| 777 } else { | |
| 778 std::string key = entry_->GetKey(); | |
| 779 msg.buffer_bytes = std::min(key.size() + 1, | |
| 780 static_cast<size_t>(kBufferSize)); | |
| 781 memcpy(output_->buffer, key.c_str(), msg.buffer_bytes); | |
| 782 if (msg.buffer_bytes != static_cast<int32>(key.size() + 1)) { | |
| 783 // We don't support moving this entry. Just tell the master. | |
| 784 msg.result = RESULT_NAME_OVERFLOW; | |
| 785 } else { | |
| 786 msg.result = RESULT_OK; | |
| 787 } | |
| 788 } | |
| 789 SendMsg(msg); | |
| 790 } | |
| 791 | |
| 792 void SlaveSM::DoGetUseTimes() { | |
| 793 DEBUGMSG("\t\t\tSlave DoGetUseTimes\n"); | |
| 794 Message msg; | |
| 795 msg.command = GET_USE_TIMES; | |
| 796 | |
| 797 if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_)) { | |
| 798 msg.result = RESULT_INVALID_PARAMETER; | |
| 799 } else { | |
| 800 msg.long_arg2 = entry_->GetLastUsed().ToInternalValue(); | |
| 801 msg.long_arg3 = entry_->GetLastModified().ToInternalValue(); | |
| 802 msg.result = RESULT_OK; | |
| 803 } | |
| 804 SendMsg(msg); | |
| 805 } | |
| 806 | |
| 807 void SlaveSM::DoGetDataSize() { | |
| 808 DEBUGMSG("\t\t\tSlave DoGetDataSize\n"); | |
| 809 Message msg; | |
| 810 msg.command = GET_DATA_SIZE; | |
| 811 | |
| 812 int stream = input_->msg.arg1; | |
| 813 if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_) || | |
| 814 stream < 0 || stream >= kNumStreams) { | |
| 815 msg.result = RESULT_INVALID_PARAMETER; | |
| 816 } else { | |
| 817 msg.arg1 = stream; | |
| 818 msg.arg2 = entry_->GetDataSize(stream); | |
| 819 msg.result = RESULT_OK; | |
| 820 } | |
| 821 SendMsg(msg); | |
| 822 } | |
| 823 | |
| 824 void SlaveSM::DoReadData() { | |
| 825 DEBUGMSG("\t\t\tSlave DoReadData\n"); | |
| 826 Message msg; | |
| 827 msg.command = READ_DATA; | |
| 828 | |
| 829 int stream = input_->msg.arg1; | |
| 830 int size = input_->msg.arg2; | |
| 831 if (!entry_ || input_->msg.long_arg1 != reinterpret_cast<int64>(entry_) || | |
| 832 stream < 0 || stream > 1 || size > kBufferSize) { | |
| 833 msg.result = RESULT_INVALID_PARAMETER; | |
| 834 } else { | |
| 835 scoped_refptr<net::WrappedIOBuffer> buf = | |
| 836 new net::WrappedIOBuffer(output_->buffer); | |
| 837 int ret = entry_->ReadData(stream, input_->msg.arg3, buf, size, | |
| 838 base::Bind(&SlaveSM::DoReadDataComplete, | |
| 839 base::Unretained(this))); | |
| 840 if (ret == net::ERR_IO_PENDING) { | |
| 841 // Save the message so we can continue were we left. | |
| 842 msg_ = msg; | |
| 843 return; | |
| 844 } | |
| 845 | |
| 846 msg.buffer_bytes = (ret < 0) ? 0 : ret; | |
| 847 msg.result = RESULT_OK; | |
| 848 } | |
| 849 SendMsg(msg); | |
| 850 } | |
| 851 | |
| 852 void SlaveSM::DoReadDataComplete(int ret) { | |
| 853 DEBUGMSG("\t\t\tSlave DoReadDataComplete\n"); | |
| 854 DCHECK_EQ(READ_DATA, msg_.command); | |
| 855 msg_.buffer_bytes = (ret < 0) ? 0 : ret; | |
| 856 msg_.result = RESULT_OK; | |
| 857 SendMsg(msg_); | |
| 858 } | |
| 859 | |
| 860 void SlaveSM::DoEnd() { | |
| 861 DEBUGMSG("\t\t\tSlave DoEnd\n"); | |
| 862 base::MessageLoop::current()->PostTask(FROM_HERE, | |
| 863 base::MessageLoop::QuitClosure()); | |
| 864 } | |
| 865 | |
| 866 void SlaveSM::Fail() { | |
| 867 DEBUGMSG("\t\t\tSlave Fail\n"); | |
| 868 printf("Unexpected failure\n"); | |
| 869 state_ = SLAVE_END; | |
| 870 if (IsPending()) { | |
| 871 CancelIo(channel_); | |
| 872 } else { | |
| 873 DoEnd(); | |
| 874 } | |
| 875 } | |
| 876 | |
| 877 } // namespace. | |
| 878 | |
| 879 // ----------------------------------------------------------------------- | |
| 880 | |
| 881 HANDLE CreateServer(base::string16* pipe_number) { | |
| 882 base::string16 pipe_name(kPipePrefix); | |
| 883 srand(static_cast<int>(base::Time::Now().ToInternalValue())); | |
| 884 *pipe_number = base::IntToString16(rand()); | |
| 885 pipe_name.append(*pipe_number); | |
| 886 | |
| 887 DWORD mode = PIPE_ACCESS_DUPLEX | FILE_FLAG_FIRST_PIPE_INSTANCE | | |
| 888 FILE_FLAG_OVERLAPPED; | |
| 889 | |
| 890 return CreateNamedPipe(pipe_name.c_str(), mode, 0, 1, kChannelSize, | |
| 891 kChannelSize, 0, NULL); | |
| 892 } | |
| 893 | |
| 894 // This is the controller process for an upgrade operation. | |
| 895 int UpgradeCache(const base::FilePath& output_path, HANDLE pipe) { | |
| 896 base::MessageLoopForIO loop; | |
| 897 | |
| 898 MasterSM master(output_path, pipe); | |
| 899 if (!master.DoInit()) { | |
| 900 printf("Unable to talk with the helper\n"); | |
| 901 return -1; | |
| 902 } | |
| 903 | |
| 904 loop.Run(); | |
| 905 return 0; | |
| 906 } | |
| 907 | |
| 908 // This process will only execute commands from the controller. | |
| 909 int RunSlave(const base::FilePath& input_path, | |
| 910 const base::string16& pipe_number) { | |
| 911 base::MessageLoopForIO loop; | |
| 912 | |
| 913 base::win::ScopedHandle pipe(OpenServer(pipe_number)); | |
| 914 if (!pipe.IsValid()) { | |
| 915 printf("Unable to open the server pipe\n"); | |
| 916 return -1; | |
| 917 } | |
| 918 | |
| 919 SlaveSM slave(input_path, pipe); | |
| 920 if (!slave.DoInit()) { | |
| 921 printf("Unable to talk with the main process\n"); | |
| 922 return -1; | |
| 923 } | |
| 924 | |
| 925 loop.Run(); | |
| 926 return 0; | |
| 927 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 547513002:
Remove disk_cache::BackendImpl::OpenPrevEntry() and all users. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master