Enforce WARN_UNUSED_RESULT attribute on Windows

chrome/utility/importer/ie_importer_win.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 "chrome/utility/importer/ie_importer_win.h"
 
 #include <ole2.h>
 #include <intshcut.h>
 #include <shlobj.h>
 #include <urlhist.h>
@@ skipping 142 matching lines @@
 // recorded in the REG_BINARY value named "Order" of the corresponding key.
 // The content of the "Order" value is a raw binary dump of an array of the
 // following data structure
 //   struct {
 //     uint32 size;  // Note that ITEMIDLIST is variably-sized.
 //     uint32 sort_index;  // 0 means this is the first item, 1 the second, ...
 //     ITEMIDLIST item_id;
 //   };
 // where each item_id should correspond to a favorites link file (*.url) in
 // the current folder.
-bool ParseFavoritesOrderBlob(
-    const Importer* importer,
-    const std::vector<uint8>& blob,
-    const base::FilePath& path,
-    std::map<base::FilePath, uint32>* sort_index) WARN_UNUSED_RESULT {
+// GCC, in its infinite wisdom, does not allow WARN_UNUSED_RESULT to be used in

[Lei Zhang, 2015/10/07 16:28:09]

What is GCC doing touching a _win.cc file? Did you mean Clang? Can we fix Clang
if that's what you meant?

[dcheng, 2015/10/07 16:41:34]

GCC only allows function attributes on prototypes.
Therefore, clang emits a warning for GCC compatibility.
I'm honestly not sure what the best thing to say here is: I guess we could have
clang-cl implicitly disable -Wgcc-compat

[Lei Zhang, 2015/10/07 20:33:11]

Can you mention the clang / gcc compatibility issue? Otherwise it's confusing
for readers.

[dcheng, 2015/10/08 03:48:07]

Done.

+// a definition.
+bool ParseFavoritesOrderBlob(const Importer* importer,
+                             const std::vector<uint8>& blob,
+                             const base::FilePath& path,
+                             std::map<base::FilePath, uint32>* sort_index)
+    WARN_UNUSED_RESULT;
+bool ParseFavoritesOrderBlob(const Importer* importer,
+                             const std::vector<uint8>& blob,
+                             const base::FilePath& path,
+                             std::map<base::FilePath, uint32>* sort_index) {
   static const int kItemCountOffset = 16;
   static const int kItemListStartOffset = 20;
 
   // Read the number of items.
   uint32 item_count = 0;
   if (!BinaryRead(&item_count, kItemCountOffset, blob))
     return false;
 
   // Traverse over the items.
   size_t base_offset = kItemListStartOffset;
@@ skipping 27 matching lines @@
     sort_index->insert(std::make_pair(item_relative_path, item_sort_index));
     base_offset += item_size;
   }
   return true;
 }
 
 bool ParseFavoritesOrderRegistryTree(
     const Importer* importer,
     const base::win::RegKey& key,
     const base::FilePath& path,
-    std::map<base::FilePath, uint32>* sort_index) WARN_UNUSED_RESULT {
+    std::map<base::FilePath, uint32>* sort_index) WARN_UNUSED_RESULT;
+bool ParseFavoritesOrderRegistryTree(
+    const Importer* importer,
+    const base::win::RegKey& key,
+    const base::FilePath& path,
+    std::map<base::FilePath, uint32>* sort_index) {
   // Parse the order information of the current folder.
   DWORD blob_length = 0;
   if (key.ReadValue(L"Order", NULL, &blob_length, NULL) == ERROR_SUCCESS) {
     std::vector<uint8> blob(blob_length);
     if (blob_length > 0 &&
         key.ReadValue(L"Order", reinterpret_cast<DWORD*>(&blob[0]),
                       &blob_length, NULL) == ERROR_SUCCESS) {
       if (!ParseFavoritesOrderBlob(importer, blob, path, sort_index))
         return false;
     }
   }
 
   // Recursively parse subfolders.
   for (base::win::RegistryKeyIterator child(key.Handle(), L"");
        child.Valid() && !importer->cancelled();
        ++child) {
     base::win::RegKey subkey(key.Handle(), child.Name(), KEY_READ);
     if (subkey.Valid()) {
       base::FilePath subpath(path.Append(child.Name()));
       if (!ParseFavoritesOrderRegistryTree(importer, subkey, subpath,
                                            sort_index)) {
         return false;
       }
     }
   }
   return true;
 }
 
-bool ParseFavoritesOrderInfo(
-    const Importer* importer,
-    std::map<base::FilePath, uint32>* sort_index) WARN_UNUSED_RESULT {
+bool ParseFavoritesOrderInfo(const Importer* importer,
+                             std::map<base::FilePath, uint32>* sort_index)
+    WARN_UNUSED_RESULT;
+bool ParseFavoritesOrderInfo(const Importer* importer,
+                             std::map<base::FilePath, uint32>* sort_index) {
   base::string16 key_path(importer::GetIEFavoritesOrderKey());
   base::win::RegKey key(HKEY_CURRENT_USER, key_path.c_str(), KEY_READ);
   if (!key.Valid())
     return false;
   return ParseFavoritesOrderRegistryTree(importer, key, base::FilePath(),
                                          sort_index);
 }
 
 // Reads the sort order from registry. If failed, we don't touch the list
 // and use the default (alphabetical) order.
@@ skipping 628 matching lines @@
   static int version = -1;
   if (version < 0) {
     wchar_t buffer[128];
     DWORD buffer_length = sizeof(buffer);
     base::win::RegKey reg_key(HKEY_LOCAL_MACHINE, kIEVersionKey, KEY_READ);
     LONG result = reg_key.ReadValue(L"Version", buffer, &buffer_length, NULL);
     version = ((result == ERROR_SUCCESS)? _wtoi(buffer) : 0);
   }
   return version;
 }