Update from https://crrev.com/306655

net/url_request/url_request_unittest.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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shlobj.h>
 #endif
@@ skipping 240 matching lines @@
       new UploadBytesElementReader(data, strlen(data)));
   return ElementsUploadDataStream::CreateWithReader(reader.Pass(), 0);
 }
 
 // Verify that the SSLInfo of a successful SSL connection has valid values.
 void CheckSSLInfo(const SSLInfo& ssl_info) {
   // -1 means unknown.  0 means no encryption.
   EXPECT_GT(ssl_info.security_bits, 0);
 
   // The cipher suite TLS_NULL_WITH_NULL_NULL (0) must not be negotiated.
-  int cipher_suite = SSLConnectionStatusToCipherSuite(
+  uint16 cipher_suite = SSLConnectionStatusToCipherSuite(
       ssl_info.connection_status);
-  EXPECT_NE(0, cipher_suite);
+  EXPECT_NE(0U, cipher_suite);
 }
 
 void CheckFullRequestHeaders(const HttpRequestHeaders& headers,
                              const GURL& host_url) {
   std::string sent_value;
 
   EXPECT_TRUE(headers.GetHeader("Host", &sent_value));
   EXPECT_EQ(GetHostAndOptionalPort(host_url), sent_value);
 
   EXPECT_TRUE(headers.GetHeader("Connection", &sent_value));
@@ skipping 3482 matching lines @@
   int upper_bound = 1;
 
   // Double the number of cookies until the response header limits are
   // exceeded.
   while (DoManyCookiesRequest(upper_bound)) {
     lower_bound = upper_bound;
     upper_bound *= 2;
     ASSERT_LT(upper_bound, 1000000);
   }
 
-  int tolerance = upper_bound * 0.005;
+  int tolerance = static_cast<int>(upper_bound * 0.005);
   if (tolerance < 2)
     tolerance = 2;
 
   // Perform a binary search to find the highest possible number of cookies,
   // within the desired tolerance.
   while (upper_bound - lower_bound >= tolerance) {
     int num_cookies = (lower_bound + upper_bound) / 2;
 
     if (DoManyCookiesRequest(num_cookies))
       lower_bound = num_cookies;
@@ skipping 1185 matching lines @@
                                     kuint64max,
                                     base::Time()));
     r->set_upload(make_scoped_ptr<UploadDataStream>(
         new ElementsUploadDataStream(element_readers.Pass(), 0)));
 
     r->Start();
     EXPECT_TRUE(r->is_pending());
 
     base::RunLoop().Run();
 
-    int64 size = 0;
-    ASSERT_EQ(true, base::GetFileSize(path, &size));
+    int64 size64 = 0;
+    ASSERT_EQ(true, base::GetFileSize(path, &size64));
+    ASSERT_LE(size64, std::numeric_limits<int>::max());
+    int size = static_cast<int>(size64);
     scoped_ptr<char[]> buf(new char[size]);
 
     ASSERT_EQ(size, base::ReadFile(path, buf.get(), size));
 
     ASSERT_EQ(1, d.response_started_count())
         << "request failed: " << r->status().status()
         << ", error: " << r->status().error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
@@ skipping 3831 matching lines @@
 
     EXPECT_FALSE(r->is_pending());
     EXPECT_EQ(1, d->response_started_count());
     EXPECT_FALSE(d->received_data_before_response());
     EXPECT_EQ(d->bytes_received(), static_cast<int>(file_size));
   }
 }
 #endif  // !defined(DISABLE_FTP_SUPPORT)
 
 }  // namespace net