Port some more parts of browser/...

chrome/browser/safe_browsing/safe_browsing_database_impl.cc

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/safe_browsing/safe_browsing_database_impl.h"
 
+#include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/platform_thread.h"
 #include "base/sha2.h"
 #include "base/string_util.h"
 #include "chrome/browser/safe_browsing/bloom_filter.h"
 #include "chrome/browser/safe_browsing/chunk_range.h"
 #include "chrome/common/sqlite_compiled_statement.h"
 #include "chrome/common/sqlite_utils.h"
 #include "googleurl/src/gurl.h"
 
 // Database version.  If this is different than what's stored on disk, the
 // database is reset.
@@ skipping 29 matching lines @@
 // How long to wait after updating the database to write the bloom filter.
 static const int kBloomFilterWriteDelayMs = (60 * 1000);
 
 // The maximum staleness for a cached entry.
 static const int kMaxStalenessMinutes = 45;
 
 // Implementation --------------------------------------------------------------
 
 SafeBrowsingDatabaseImpl::SafeBrowsingDatabaseImpl()
     : db_(NULL),
+      transaction_count_(0),
       init_(false),
-      transaction_count_(0),
       asynchronous_(true),
       chunk_inserted_callback_(NULL),
-#pragma warning(suppress: 4355)  // can use this
-      bloom_read_factory_(this),
-#pragma warning(suppress: 4355)  // can use this
-      bloom_write_factory_(this),
-#pragma warning(suppress: 4355)  // can use this
-      process_factory_(this),
-#pragma warning(suppress: 4355)  // can use this
-      reset_factory_(this),
-#pragma warning(suppress: 4355)  // can use this
-      resume_factory_(this),
+      ALLOW_THIS_IN_INITIALIZER_LIST(process_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(bloom_read_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(bloom_write_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(reset_factory_(this)),
+      ALLOW_THIS_IN_INITIALIZER_LIST(resume_factory_(this)),
       disk_delay_(kMaxThreadHoldupMs) {
 }
 
 SafeBrowsingDatabaseImpl::~SafeBrowsingDatabaseImpl() {
   Close();
 }
 
 bool SafeBrowsingDatabaseImpl::Init(const std::wstring& filename,
                                     Callback0::Type* chunk_inserted_callback) {
   DCHECK(!init_ && filename_.empty());
@@ skipping 383 matching lines @@
 
     if (asynchronous_) {
       // For production code, we want to throttle by calling InvokeLater to
       // continue the work after a delay.  However for unit tests we depend on
       // updates to happen synchronously.
       MessageLoop::current()->PostDelayedTask(FROM_HERE,
           process_factory_.NewRunnableMethod(
               &SafeBrowsingDatabaseImpl::RunThrottledWork), disk_delay_);
       break;
     } else {
-      Sleep(kMaxThreadHoldupMs);
+      PlatformThread::Sleep(kMaxThreadHoldupMs);
     }
   }
 }
 
 void SafeBrowsingDatabaseImpl::InsertChunks(const std::string& list_name,
                                             std::deque<SBChunk>* chunks) {
   // We've going to be updating the bloom filter, so delete the on-disk
   // serialization so that if the process crashes we'll generate a new one on
   // startup, instead of reading a stale filter.
   DeleteBloomFilter();
@@ skipping 520 matching lines @@
       break;
     }
 
     count++;
     bloom_filter_temp_hostkeys_.push_back(statement->column_int(0));
     next_id = statement->column_int(1) + 1;
     if ((Time::Now() - before).InMilliseconds() > kMaxThreadHoldupMs) {
       if (asynchronous_) {
         break;
       } else {
-        Sleep(kMaxThreadHoldupMs);
+        PlatformThread::Sleep(kMaxThreadHoldupMs);
       }
     }
   }
 
   TimeDelta chunk_time = Time::Now() - before;
   int time_ms = static_cast<int>(chunk_time.InMilliseconds());
   SB_DLOG(INFO) << "SafeBrowsingDatabaseImpl read " << count
                 << " hostkeys in " << time_ms << " ms";
 
   if (!count || !asynchronous_) {
@@ skipping 145 matching lines @@
   while (it != hash_cache_.end()) {
     HashList& entries = it->second;
     HashList::iterator eit = entries.begin();
     while (eit != entries.end()) {
       if (eit->list_id == list_id && eit->add_chunk_id == add_chunk_id)
         eit = entries.erase(eit);
       else
         ++eit;
     }
     if (entries.empty())
-      it = hash_cache_.erase(it);
+      hash_cache_.erase(it++);
     else
       ++it;
   }
 }
 
 void SafeBrowsingDatabaseImpl::HandleCorruptDatabase() {
   MessageLoop::current()->PostTask(FROM_HERE,
       reset_factory_.NewRunnableMethod(
           &SafeBrowsingDatabaseImpl::OnHandleCorruptDatabase));
 }
@@ skipping 12 matching lines @@
       kOnResumeHoldupMs);
 }
 
 void SafeBrowsingDatabaseImpl::OnResumeDone() {
   disk_delay_ = kMaxThreadHoldupMs;
 }
 
 void SafeBrowsingDatabaseImpl::SetSynchronous() {
   asynchronous_ = false;
 }