Use important_file_writer to write .ico files

ui/gfx/icon_util.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 "ui/gfx/icon_util.h"
 
 #include "base/file_util.h"
+#include "base/files/important_file_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/win/resource_util.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/scoped_hdc.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/gdi_util.h"
 #include "ui/gfx/image/image.h"
@@ skipping 445 matching lines @@
   if (!ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes))
     return false;
 
   // Guaranteed true because BuildResizedImageFamily will provide at least one
   // image < 256x256.
   DCHECK(!bitmaps.empty());
   size_t bitmap_count = bitmaps.size();  // Not including PNG image.
   // Including PNG image, if any.
   size_t image_count = bitmap_count + (png_bytes.get() ? 1 : 0);
 
-  // Now that basic checks are done, we can create the file.
-  base::win::ScopedHandle icon_file(::CreateFile(icon_path.value().c_str(),
-       GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL));
-
-  if (!icon_file.IsValid())
-    return false;
-
   // Computing the total size of the buffer we need in order to store the
   // images in the desired icon format.
   size_t buffer_size = ComputeIconFileBufferSize(bitmaps);
   // Account for the bytes needed for the PNG entry.
   if (png_bytes.get())
     buffer_size += sizeof(ICONDIRENTRY) + png_bytes->size();
 
   // Setting the information in the structures residing within the buffer.
   // First, we set the information which doesn't require iterating through the
   // bitmap set and then we set the bitmap specific structures. In the latter
@@ skipping 24 matching lines @@
     entry->wPlanes = 1;
     entry->wBitCount = 32;
     entry->dwBytesInRes = static_cast<DWORD>(png_bytes->size());
     entry->dwImageOffset = static_cast<DWORD>(offset);
     memcpy(&buffer[offset], png_bytes->front(), png_bytes->size());
     offset += png_bytes->size();
   }
 
   DCHECK_EQ(offset, buffer_size);
 
-  // Finally, write the data to the file.
-  DWORD bytes_written;
-  bool delete_file = false;
-  if (!WriteFile(icon_file.Get(), &buffer[0], buffer_size, &bytes_written,
-                 NULL) ||
-      bytes_written != buffer_size) {
-    delete_file = true;
-  }
-
-  ::CloseHandle(icon_file.Take());
-  if (delete_file) {
-    bool success = file_util::Delete(icon_path, false);
-    DCHECK(success);
-  }
-
-  return !delete_file;
+  std::string data(buffer.begin(), buffer.end());
+  return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
 }
 
 bool IconUtil::PixelsHaveAlpha(const uint32* pixels, size_t num_pixels) {
   for (const uint32* end = pixels + num_pixels; pixels != end; ++pixels) {
     if ((*pixels & 0xff000000) != 0)
       return true;
   }
 
   return false;
 }
@@ skipping 150 matching lines @@
   // Once we compute the size for a singe AND mask scan line, we multiply that
   // number by the image height in order to get the total number of bytes for
   // the AND mask. Thus, for a 15X15 image, we need 15 * 4 which is 60 bytes
   // for the monochrome bitmap representing the AND mask.
   size_t and_line_length = (bitmap.width() + 7) >> 3;
   and_line_length = (and_line_length + 3) & ~3;
   size_t and_mask_size = and_line_length * bitmap.height();
   size_t masks_size = *xor_mask_size + and_mask_size;
   *bytes_in_resource = masks_size + sizeof(BITMAPINFOHEADER);
 }