Fixing remaining VC++ 2015 64-bit build breaks

chrome/app/close_handle_hook_win.cc

 // Copyright 2014 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/app/close_handle_hook_win.h"
 
 #include <Windows.h>
 #include <psapi.h>
 
 #include <vector>
@@ skipping 124 matching lines @@
 
   if (!(*old_function))
     *old_function = pe.RVAToAddr(*eat_entry);
 
   AutoProtectMemory memory;
   if (!memory.ChangeProtection(eat_entry, sizeof(DWORD)))
     return;
 
   // Perform the patch.
 #pragma warning(push)
-#pragma warning(disable: 4311)
-  // These casts generate warnings because they are 32 bit specific.
+#pragma warning(disable : 4311 4302)
+  // These casts generate truncation warnings because they are 32 bit specific.
   *eat_entry = reinterpret_cast<DWORD>(new_function) -
                reinterpret_cast<DWORD>(module);

[Nico, 2015/11/18 02:02:35]

I guess we don't run this code in 64-bit?

[brucedawson, 2015/11/18 02:06:04]

Correct. UseHooks (line 234) unconditionally returns false in 64-bit builds. I
think a case could be made for wrapping this code in the same #ifdef, but I
didn't quite convince myself to do it. It's tempting because it avoids the
#pragmas, but it requires more #ifdefs, but they're pretty safe #ifdefs, but...

[Will Harris, 2015/11/18 02:08:17]

looks like these should look more like the EAT hooks in sandbox

https://code.google.com/p/chromium/codesearch#chromium/src/sandbox/win/src/ea...

[Nico, 2015/11/18 02:09:39]

Yeah, if this isn't called on 64-bit then it should only be compiled there. If
this didn't go through the UseHooks() indirection, -Wunused-function would've
even complained about this at compile time.

Doesn't have to be in this CL though, or doesn't even have to be done by you.
Thanks for explaining!

 #pragma warning(pop)
 }
 
 // Performs an IAT interception.
 base::win::IATPatchFunction* IATPatch(HMODULE module, const char* function_name,
                                       void* new_function, void** old_function) {
   if (!module)
     return NULL;
 
   base::win::IATPatchFunction* patch = new base::win::IATPatchFunction;
@@ skipping 116 matching lines @@
     PatchLoadedModules(hooks);
   } else {
     base::win::DisableHandleVerifier();
   }
 }
 
 void RemoveHandleHooks() {
   // We are partching all loaded modules without forcing them to stay in memory,
   // removing patches is not safe.
 }