Some platform cleanup to net/

src/net/http/http_cache_unittest.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 "net/http/http_cache.h"
 
-#include <windows.h>
-
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
 #include "net/base/load_flags.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-#pragma warning(disable: 4355)
-
 namespace {
 
 //-----------------------------------------------------------------------------
 // mock disk cache (a very basic memory cache implementation)
 
 class MockDiskEntry : public disk_cache::Entry,
                       public base::RefCounted<MockDiskEntry> {
  public:
   MockDiskEntry() : test_mode_(0), doomed_(false) {
   }
@@ skipping 33 matching lines @@
     DCHECK(index >= 0 && index < 2);
     return static_cast<int32>(data_[index].size());
   }
 
   virtual int ReadData(int index, int offset, char* buf, int buf_len,
                        net::CompletionCallback* callback) {
     DCHECK(index >= 0 && index < 2);
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
-    if (offset == data_[index].size())
+    if (static_cast<size_t>(offset) == data_[index].size())
       return 0;
 
     int num = std::min(buf_len, static_cast<int>(data_[index].size()) - offset);
     memcpy(buf, &data_[index][offset], num);
 
     if (!callback || (test_mode_ & TEST_MODE_SYNC_CACHE_READ))
       return num;
 
     CallbackLater(callback, num);
     return net::ERR_IO_PENDING;
@@ skipping 389 matching lines @@
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.request_headers = "cache-control: max-age=0";
 
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
+struct Context {
+  int result;
+  TestCompletionCallback callback;
+  net::HttpTransaction* trans;
+
+  Context(net::HttpTransaction* t) : result(net::ERR_IO_PENDING), trans(t) {
+  }
+};
+
 TEST(HttpCache, SimpleGET_ManyReaders) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  struct Context {
-    int result;
-    TestCompletionCallback callback;
-    net::HttpTransaction* trans;
-
-    Context(net::HttpTransaction* t) : result(net::ERR_IO_PENDING), trans(t) {
-    }
-  };
-
   std::vector<Context*> context_list;
   const int kNumTransactions = 5;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(
         new Context(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
     int rv = c->trans->Start(&request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
@@ skipping 25 matching lines @@
     c->trans->Destroy();
     delete c;
   }
 }
 
 TEST(HttpCache, SimpleGET_ManyWriters_CancelFirst) {
   MockHttpCache cache;
 
   MockHttpRequest request(kSimpleGET_Transaction);
 
-  struct Context {
-    int result;
-    TestCompletionCallback callback;
-    net::HttpTransaction* trans;
-
-    Context(net::HttpTransaction* t) : result(net::ERR_IO_PENDING), trans(t) {
-    }
-  };
-
   std::vector<Context*> context_list;
   const int kNumTransactions = 2;
 
   for (int i = 0; i < kNumTransactions; ++i) {
     context_list.push_back(
         new Context(cache.http_cache()->CreateTransaction()));
 
     Context* c = context_list[i];
     int rv = c->trans->Start(&request, &c->callback);
     if (rv != net::ERR_IO_PENDING)
@@ skipping 414 matching lines @@
   net::HttpTransaction* trans = cache.http_cache()->CreateTransaction();
   ASSERT_TRUE(trans);
 
   int rv = trans->Start(&request, &callback);
   if (rv == net::ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_EQ(net::ERR_CACHE_MISS, rv);
 
   trans->Destroy();
 }