Fixed i-cursor height calculation.

ui/views/corewm/cursor_height_provider_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 "ui/views/corewm/cursor_height_provider_win.h"
 
 #include <windows.h>
 #include <algorithm>
 #include <map>
 
@@ skipping 87 matching lines @@
     last_byte_mask = (last_byte_mask << bits_to_shift);
   else
     last_byte_mask = 0;
 
   const uint32_t row_size =
       (bitmap_info.bmiHeader.biWidth + kBitsPeruint32 - 1) / kBitsPeruint32;
   PixelData data(GetBitmapData(icon.hbmMask, bitmap_info, hdc));
   if (data == NULL)
     return kDefaultHeight;
 
-  const int cursor_height = GetSystemMetrics(SM_CYCURSOR);
-  // Crash data seems to indicate cursor_height may be bigger than the bitmap.
-  int i = std::max(0, static_cast<int>(bitmap_info.bmiHeader.biHeight) -
-                   cursor_height);
-  for (; i < bitmap_info.bmiHeader.biHeight; ++i) {
-    if (!IsRowTransparent(data, row_size, last_byte_mask, i)) {
-      i--;
+  // There are 2 types of cursors: Ones that cover the area underneath
+  // completely (i.e. hand cursor) and ones that partially cover
+  // and partially blend with background (i. e. I-beam cursor).
+  // These will have either 1 square mask or 2 masks stacked on top
+  // of each other (xor mask and and mask).
+  const bool has_xor_mask =
+      bitmap_info.bmiHeader.biHeight == 2 * bitmap_info.bmiHeader.biWidth;
+  const int cursor_height =
+      has_xor_mask ? static_cast<int>(bitmap_info.bmiHeader.biHeight / 2)
+                   : static_cast<int>(bitmap_info.bmiHeader.biHeight);
+  int xor_offset;
+  if (has_xor_mask) {
+    for (xor_offset = 0; xor_offset < cursor_height; ++xor_offset) {
+      const uint32_t row_start = row_size * xor_offset;
+      const uint32_t row_boundary = row_start + row_size;
+      for (uint32_t i = row_start; i < row_boundary; ++i)
+        data.get()[i] = ~(data.get()[i]);
+      if (!IsRowTransparent(data, row_size, last_byte_mask, xor_offset)) {
+        break;
+      }
+    }
+  } else {
+    xor_offset = cursor_height;
+  }
+
+  int and_offset;
+
+  for (and_offset = has_xor_mask ? cursor_height : 0;
+       and_offset < bitmap_info.bmiHeader.biHeight; ++and_offset) {
+    if (!IsRowTransparent(data, row_size, last_byte_mask, and_offset)) {
       break;
     }
   }
-  return bitmap_info.bmiHeader.biHeight - i - icon.yHotspot;
+  if (has_xor_mask) {
+    and_offset -= cursor_height;
+  }
+  const int offset = std::min(xor_offset, and_offset);
+
+  DeleteObject(icon.hbmColor);
+  DeleteObject(icon.hbmMask);
+
+  return cursor_height - offset - icon.yHotspot + 1;
 }
 
 }  // namespace
 
 namespace views {
 namespace corewm {
 
 int GetCurrentCursorVisibleHeight() {
   CURSORINFO cursor = {0};
   cursor.cbSize = sizeof(cursor);
   GetCursorInfo(&cursor);
 
   if (cached_heights == NULL)
     cached_heights = new HeightStorage;
 
   HeightStorage::const_iterator cached_height =
       cached_heights->find(cursor.hCursor);
   if (cached_height != cached_heights->end())
     return cached_height->second;
 
   const int height = CalculateCursorHeight(cursor.hCursor);
   (*cached_heights)[cursor.hCursor] = height;
 
   return height;
 }
 
 }  // namespace corewm
 }  // namespace views