Skip flushes on icon writes for 10x better jumplist perf

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/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/trace_event/trace_event.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/geometry/size.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_family.h"
@@ skipping 424 matching lines @@
   ::SelectObject(dib_dc, old_obj);
   ::DeleteObject(dib);
   ::DeleteDC(dib_dc);
 
   return bitmap;
 }
 
 // static
 bool IconUtil::CreateIconFileFromImageFamily(
     const gfx::ImageFamily& image_family,
-    const base::FilePath& icon_path) {
+    const base::FilePath& icon_path,
+    WriteType write_type) {
   // Creating a set of bitmaps corresponding to the icon images we'll end up
   // storing in the icon file. Each bitmap is created by resizing the most
   // appropriate image from |image_family| to the desired size.
   gfx::ImageFamily resized_image_family;
   if (!BuildResizedImageFamily(image_family, &resized_image_family))
     return false;
 
   std::vector<SkBitmap> bitmaps;
   scoped_refptr<base::RefCountedMemory> png_bytes;
   if (!ConvertImageFamilyToBitmaps(resized_image_family, &bitmaps, &png_bytes))
@@ skipping 43 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);
 
-  std::string data(buffer.begin(), buffer.end());
-  return base::ImportantFileWriter::WriteFileAtomically(icon_path, data);
+  if (write_type == NORMAL_WRITE) {
+    auto saved_size =
+        base::WriteFile(icon_path, reinterpret_cast<const char*>(&buffer[0]),
+                        static_cast<int>(buffer.size()));
+    if (saved_size == static_cast<int>(buffer.size()))
+      return true;
+    bool delete_success = base::DeleteFile(icon_path, false);
+    DCHECK(delete_success);
+    return false;
+  } else {
+    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);
 }