Switch to standard integer types in net/.

net/disk_cache/cache_creator.cc

 // Copyright (c) 2012 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 "base/files/file_path.h"
+#include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/memory/mem_backend_impl.h"
 #include "net/disk_cache/simple/simple_backend_impl.h"
 
 namespace {
 
 // Builds an instance of the backend depending on platform, type, experiments
 // etc. Takes care of the retry state. This object will self-destroy when
 // finished.
 class CacheCreator {
  public:
   CacheCreator(const base::FilePath& path,
                bool force,
                int max_bytes,
                net::CacheType type,
                net::BackendType backend_type,
-               uint32 flags,
+               uint32_t flags,
                const scoped_refptr<base::SingleThreadTaskRunner>& thread,
                net::NetLog* net_log,
                scoped_ptr<disk_cache::Backend>* backend,
                const net::CompletionCallback& callback);
 
   // Creates the backend.
   int Run();
 
  private:
   ~CacheCreator();
 
   void DoCallback(int result);
 
   void OnIOComplete(int result);
 
   const base::FilePath path_;
   bool force_;
   bool retry_;
   int max_bytes_;
   net::CacheType type_;
   net::BackendType backend_type_;
-  uint32 flags_;
+  uint32_t flags_;
   scoped_refptr<base::SingleThreadTaskRunner> thread_;
   scoped_ptr<disk_cache::Backend>* backend_;
   net::CompletionCallback callback_;
   scoped_ptr<disk_cache::Backend> created_cache_;
   net::NetLog* net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(CacheCreator);
 };
 
 CacheCreator::CacheCreator(
     const base::FilePath& path,
     bool force,
     int max_bytes,
     net::CacheType type,
     net::BackendType backend_type,
-    uint32 flags,
+    uint32_t flags,
     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
     net::NetLog* net_log,
     scoped_ptr<disk_cache::Backend>* backend,
     const net::CompletionCallback& callback)
     : path_(path),
       force_(force),
       retry_(false),
       max_bytes_(max_bytes),
       type_(type),
       backend_type_(backend_type),
       flags_(flags),
       thread_(thread),
       backend_(backend),
       callback_(callback),
-      net_log_(net_log) {
-}
+      net_log_(net_log) {}
 
 CacheCreator::~CacheCreator() {
 }
 
 int CacheCreator::Run() {
 #if defined(OS_ANDROID)
   static const bool kSimpleBackendIsDefault = true;
 #else
   static const bool kSimpleBackendIsDefault = false;
 #endif
@@ skipping 83 matching lines @@
                                            backend_type,
                                            kNone,
                                            thread,
                                            net_log,
                                            backend,
                                            callback);
   return creator->Run();
 }
 
 }  // namespace disk_cache