Fix pointer truncation in component_unittests.

components/storage_monitor/storage_monitor_win_unittest.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 <windows.h>
 #include <dbt.h>
 
 #include <string>
 #include <vector>
 
@@ skipping 147 matching lines @@
   for (DeviceIndices::const_iterator it = device_indices.begin();
        it != device_indices.end(); ++it) {
     volume_broadcast.dbcv_unitmask |= 0x1 << *it;
     bool removable;
     ASSERT_TRUE(volume_mount_watcher_->GetDeviceRemovable(
         VolumeMountWatcherWin::DriveNumberToFilePath(*it), &removable));
     if (removable)
       expect_attach_calls++;
   }
   monitor_->InjectDeviceChange(DBT_DEVICEARRIVAL,
-                               reinterpret_cast<DWORD>(&volume_broadcast));
+                               reinterpret_cast<LPARAM>(&volume_broadcast));
 
   RunUntilIdle();
   volume_mount_watcher_->FlushWorkerPoolForTesting();
   RunUntilIdle();
 
   EXPECT_EQ(expect_attach_calls, observer_.attach_calls());
   EXPECT_EQ(0, observer_.detach_calls());
 }
 
 void StorageMonitorWinTest::DoMassStorageDevicesDetachedTest(
     const DeviceIndices& device_indices) {
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_unitmask = 0x0;
   volume_broadcast.dbcv_flags = 0x0;
 
   int pre_attach_calls = observer_.attach_calls();
   int expect_detach_calls = 0;
   for (DeviceIndices::const_iterator it = device_indices.begin();
        it != device_indices.end(); ++it) {
     volume_broadcast.dbcv_unitmask |= 0x1 << *it;
     StorageInfo info;
     ASSERT_TRUE(volume_mount_watcher_->GetDeviceInfo(
         VolumeMountWatcherWin::DriveNumberToFilePath(*it), &info));
     if (StorageInfo::IsRemovableDevice(info.device_id()))
       ++expect_detach_calls;
   }
   monitor_->InjectDeviceChange(DBT_DEVICEREMOVECOMPLETE,
-                               reinterpret_cast<DWORD>(&volume_broadcast));
+                               reinterpret_cast<LPARAM>(&volume_broadcast));
   RunUntilIdle();
   EXPECT_EQ(pre_attach_calls, observer_.attach_calls());
   EXPECT_EQ(expect_detach_calls, observer_.detach_calls());
 }
 
 void StorageMonitorWinTest::DoMTPDeviceTest(const base::string16& pnp_device_id,
                                             bool test_attach) {
   GUID guidDevInterface = GUID_NULL;
   HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &guidDevInterface);
   if (FAILED(hr))
@@ skipping 25 matching lines @@
                                                        &location, &unique_id,
                                                        &name);
     if (test_attach && !name.empty() && !unique_id.empty())
       expect_attach_calls++;
     else if (!name.empty() && !unique_id.empty())
       expect_detach_calls++;
   }
 
   monitor_->InjectDeviceChange(
       test_attach ? DBT_DEVICEARRIVAL : DBT_DEVICEREMOVECOMPLETE,
-      reinterpret_cast<DWORD>(dev_interface_broadcast.get()));
+      reinterpret_cast<LPARAM>(dev_interface_broadcast.get()));
 
   RunUntilIdle();
   EXPECT_EQ(expect_attach_calls, observer_.attach_calls());
   EXPECT_EQ(expect_detach_calls, observer_.detach_calls());
 }
 
 bool StorageMonitorWinTest::GetMTPStorageInfo(
     const std::string& storage_device_id,
     base::string16* pnp_device_id,
     base::string16* storage_object_id) {
@@ skipping 154 matching lines @@
   volume_mount_watcher_->BlockDeviceCheckForTesting();
   base::FilePath kAttachedDevicePath =
       VolumeMountWatcherWin::DriveNumberToFilePath(8);  // I:
 
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_flags = 0x0;
   volume_broadcast.dbcv_unitmask = 0x100;  // I: drive
   monitor_->InjectDeviceChange(DBT_DEVICEARRIVAL,
-                               reinterpret_cast<DWORD>(&volume_broadcast));
+                               reinterpret_cast<LPARAM>(&volume_broadcast));
 
   EXPECT_EQ(0u, volume_mount_watcher_->devices_checked().size());
 
   // Re-attach the same volume. We haven't released the mock device check
   // event, so there'll be pending calls in the UI thread to finish the
   // device check notification, blocking the duplicate device injection.
   monitor_->InjectDeviceChange(DBT_DEVICEARRIVAL,
-                               reinterpret_cast<DWORD>(&volume_broadcast));
+                               reinterpret_cast<LPARAM>(&volume_broadcast));
 
   EXPECT_EQ(0u, volume_mount_watcher_->devices_checked().size());
   volume_mount_watcher_->ReleaseDeviceCheck();
   RunUntilIdle();
   volume_mount_watcher_->ReleaseDeviceCheck();
 
   // Now let all attach notifications finish running. We'll only get one
   // finish-attach call.
   volume_mount_watcher_->FlushWorkerPoolForTesting();
   RunUntilIdle();
 
   const std::vector<base::FilePath>& checked_devices =
       volume_mount_watcher_->devices_checked();
   ASSERT_EQ(1u, checked_devices.size());
   EXPECT_EQ(kAttachedDevicePath, checked_devices[0]);
 
   // We'll receive a duplicate check now that the first check has fully cleared.
   monitor_->InjectDeviceChange(DBT_DEVICEARRIVAL,
-                               reinterpret_cast<DWORD>(&volume_broadcast));
+                               reinterpret_cast<LPARAM>(&volume_broadcast));
   volume_mount_watcher_->FlushWorkerPoolForTesting();
   volume_mount_watcher_->ReleaseDeviceCheck();
   RunUntilIdle();
 
   ASSERT_EQ(2u, checked_devices.size());
   EXPECT_EQ(kAttachedDevicePath, checked_devices[0]);
   EXPECT_EQ(kAttachedDevicePath, checked_devices[1]);
 }
 
 TEST_F(StorageMonitorWinTest, DeviceInfoForPath) {
@@ skipping 82 matching lines @@
         TestPortableDeviceWatcherWin::kMTPDeviceWithValidInfo);
     EXPECT_EQ(expected, pnp_device_id);
     EXPECT_EQ(it->object_persistent_id,
               TestPortableDeviceWatcherWin::GetMTPStorageUniqueId(
                   pnp_device_id, storage_object_id));
   }
   DoMTPDeviceTest(TestPortableDeviceWatcherWin::kMTPDeviceWithValidInfo, false);
 }
 
 }  // namespace storage_monitor