Disable tests failing on Linux MSAN tests on chromium.memory.

cc/tiles/gpu_image_decode_cache_unittest.cc

 // Copyright 2016 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 "cc/tiles/gpu_image_decode_cache.h"
 
 #include "cc/paint/draw_image.h"
 #include "cc/test/test_context_provider.h"
 #include "cc/test/test_tile_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 99 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(another_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLowerQuality) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageLowerQuality DISABLED_GetTaskForImageLowerQuality
+#else
+#define MAYBE_GetTaskForImageLowerQuality GetTaskForImageLowerQuality
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageLowerQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        kHigh_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> task;
@@ skipping 11 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(task.get() == another_task.get());
 
   TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(task.get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(another_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageDifferentImage) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageDifferentImage \
+  DISABLED_GetTaskForImageDifferentImage
+#else
+#define MAYBE_GetTaskForImageDifferentImage GetTaskForImageDifferentImage
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageDifferentImage) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 19 matching lines @@
 
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScale) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageLargerScale DISABLED_GetTaskForImageLargerScale
+#else
+#define MAYBE_GetTaskForImageLargerScale GetTaskForImageLargerScale
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageLargerScale) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 30 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task.get() == second_task.get());
 
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageLargerScaleNoReuse) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageLargerScaleNoReuse \
+  DISABLED_GetTaskForImageLargerScaleNoReuse
+#else
+#define MAYBE_GetTaskForImageLargerScaleNoReuse \
+  GetTaskForImageLargerScaleNoReuse
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageLargerScaleNoReuse) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
       quality, CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 28 matching lines @@
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageHigherQuality) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageHigherQuality DISABLED_GetTaskForImageHigherQuality
+#else
+#define MAYBE_GetTaskForImageHigherQuality GetTaskForImageHigherQuality
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageHigherQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
       kLow_SkFilterQuality, matrix, DefaultColorSpace());
@@ skipping 17 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(second_task);
   EXPECT_TRUE(first_task.get() != second_task.get());
 
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedAndLocked) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageAlreadyDecodedAndLocked \
+  DISABLED_GetTaskForImageAlreadyDecodedAndLocked
+#else
+#define MAYBE_GetTaskForImageAlreadyDecodedAndLocked \
+  GetTaskForImageAlreadyDecodedAndLocked
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageAlreadyDecodedAndLocked) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 25 matching lines @@
 
   TestTileTaskRunner::ProcessTask(another_task.get());
 
   // Finally, complete the original decode task.
   TestTileTaskRunner::CompleteTask(task->dependencies()[0].get());
 
   cache.UnrefImage(draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyDecodedNotLocked) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageAlreadyDecodedNotLocked \
+  DISABLED_GetTaskForImageAlreadyDecodedNotLocked
+#else
+#define MAYBE_GetTaskForImageAlreadyDecodedNotLocked \
+  GetTaskForImageAlreadyDecodedNotLocked
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageAlreadyDecodedNotLocked) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 25 matching lines @@
   EXPECT_TRUE(another_task);
   EXPECT_EQ(another_task->dependencies().size(), 1u);
   EXPECT_TRUE(task->dependencies()[0]);
 
   TestTileTaskRunner::ProcessTask(another_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(another_task.get());
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageAlreadyUploaded) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageAlreadyUploaded \
+  DISABLED_GetTaskForImageAlreadyUploaded
+#else
+#define MAYBE_GetTaskForImageAlreadyUploaded GetTaskForImageAlreadyUploaded
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetTaskForImageAlreadyUploaded) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 63 matching lines @@
   EXPECT_TRUE(need_unref);
   EXPECT_TRUE(third_task);
   EXPECT_FALSE(third_task.get() == task.get());
 
   TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(third_task.get());
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetTaskForImageCanceledWhileReffedGetsNewTask) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetTaskForImageCanceledWhileReffedGetsNewTask \
+  DISABLED_GetTaskForImageCanceledWhileReffedGetsNewTask
+#else
+#define MAYBE_GetTaskForImageCanceledWhileReffedGetsNewTask \
+  GetTaskForImageCanceledWhileReffedGetsNewTask
+#endif
+TEST(GpuImageDecodeCacheTest,
+     MAYBE_GetTaskForImageCanceledWhileReffedGetsNewTask) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 31 matching lines @@
   EXPECT_FALSE(third_task.get() == task.get());
 
   ASSERT_GT(third_task->dependencies().size(), 0u);
   TestTileTaskRunner::ProcessTask(third_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(third_task.get());
 
   // Unref!
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, NoTaskForImageAlreadyFailedDecoding) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_NoTaskForImageAlreadyFailedDecoding \
+  DISABLED_NoTaskForImageAlreadyFailedDecoding
+#else
+#define MAYBE_NoTaskForImageAlreadyFailedDecoding \
+  NoTaskForImageAlreadyFailedDecoding
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_NoTaskForImageAlreadyFailedDecoding) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 13 matching lines @@
 
   scoped_refptr<TileTask> another_task;
   need_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &another_task);
   EXPECT_FALSE(need_unref);
   EXPECT_EQ(another_task.get(), nullptr);
 
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDraw) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetDecodedImageForDraw DISABLED_GetDecodedImageForDraw
+#else
+#define MAYBE_GetDecodedImageForDraw GetDecodedImageForDraw
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetDecodedImageForDraw) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 84 matching lines @@
   DecodedDrawImage decoded_draw_image =
       cache.GetDecodedImageForDraw(draw_image);
   EXPECT_TRUE(decoded_draw_image.image());
   EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_TRUE(decoded_draw_image.is_at_raster_decode());
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawLargerScale) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetDecodedImageForDrawLargerScale \
+  DISABLED_GetDecodedImageForDrawLargerScale
+#else
+#define MAYBE_GetDecodedImageForDrawLargerScale \
+  GetDecodedImageForDrawLargerScale
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetDecodedImageForDrawLargerScale) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 38 matching lines @@
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   cache.DrawWithImageFinished(larger_draw_image, larger_decoded_draw_image);
   cache.UnrefImage(larger_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawHigherQuality) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetDecodedImageForDrawHigherQuality \
+  DISABLED_GetDecodedImageForDrawHigherQuality
+#else
+#define MAYBE_GetDecodedImageForDrawHigherQuality \
+  GetDecodedImageForDrawHigherQuality
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetDecodedImageForDrawHigherQuality) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        kLow_SkFilterQuality, matrix, DefaultColorSpace());
   scoped_refptr<TileTask> task;
@@ skipping 36 matching lines @@
 
   EXPECT_FALSE(decoded_draw_image.image() == larger_decoded_draw_image.image());
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   cache.DrawWithImageFinished(higher_quality_draw_image,
                               larger_decoded_draw_image);
   cache.UnrefImage(higher_quality_draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetDecodedImageForDrawNegative) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetDecodedImageForDrawNegative \
+  DISABLED_GetDecodedImageForDrawNegative
+#else
+#define MAYBE_GetDecodedImageForDrawNegative GetDecodedImageForDrawNegative
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetDecodedImageForDrawNegative) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(-0.5f, 0.5f), is_decomposable),
@@ skipping 16 matching lines @@
   EXPECT_EQ(decoded_draw_image.image()->width(), 50);
   EXPECT_EQ(decoded_draw_image.image()->height(), 50);
   EXPECT_TRUE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
 }
 
-TEST(GpuImageDecodeCacheTest, GetLargeScaledDecodedImageForDraw) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetLargeScaledDecodedImageForDraw \
+  DISABLED_GetLargeScaledDecodedImageForDraw
+#else
+#define MAYBE_GetLargeScaledDecodedImageForDraw \
+  GetLargeScaledDecodedImageForDraw
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_GetLargeScaledDecodedImageForDraw) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(1, 48000);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 18 matching lines @@
   EXPECT_EQ(24000, decoded_draw_image.image()->height());
   EXPECT_FALSE(decoded_draw_image.image()->isTextureBacked());
   EXPECT_FALSE(decoded_draw_image.is_at_raster_decode());
   EXPECT_TRUE(cache.DiscardableIsLockedForTesting(draw_image));
 
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
   cache.UnrefImage(draw_image);
   EXPECT_FALSE(cache.DiscardableIsLockedForTesting(draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, AtRasterUsedDirectlyIfSpaceAllows) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_AtRasterUsedDirectlyIfSpaceAllows \
+  DISABLED_AtRasterUsedDirectlyIfSpaceAllows
+#else
+#define MAYBE_AtRasterUsedDirectlyIfSpaceAllows \
+  AtRasterUsedDirectlyIfSpaceAllows
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_AtRasterUsedDirectlyIfSpaceAllows) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   cache.SetAllByteLimitsForTesting(0);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
@@ skipping 24 matching lines @@
   cache.DrawWithImageFinished(draw_image, decoded_draw_image);
 
   scoped_refptr<TileTask> another_task;
   bool another_task_needs_unref = cache.GetTaskForImageAndRef(
       draw_image, ImageDecodeCache::TracingInfo(), &task);
   EXPECT_TRUE(another_task_needs_unref);
   EXPECT_FALSE(another_task);
   cache.UnrefImage(draw_image);
 }
 
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_GetDecodedImageForDrawAtRasterDecodeMultipleTimes \
+  DISABLED_GetDecodedImageForDrawAtRasterDecodeMultipleTimes
+#else
+#define MAYBE_GetDecodedImageForDrawAtRasterDecodeMultipleTimes \
+  GetDecodedImageForDrawAtRasterDecodeMultipleTimes
+#endif
 TEST(GpuImageDecodeCacheTest,
-     GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
+     MAYBE_GetDecodedImageForDrawAtRasterDecodeMultipleTimes) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   cache.SetAllByteLimitsForTesting(0);
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
@@ skipping 138 matching lines @@
 
   TestTileTaskRunner::CancelTask(task->dependencies()[0].get());
   TestTileTaskRunner::CompleteTask(task->dependencies()[0].get());
   TestTileTaskRunner::CancelTask(task.get());
   TestTileTaskRunner::CompleteTask(task.get());
 
   cache.UnrefImage(draw_image);
   EXPECT_EQ(0u, cache.GetBytesUsedForTesting());
 }
 
-TEST(GpuImageDecodeCacheTest, ShouldAggressivelyFreeResources) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_ShouldAggressivelyFreeResources \
+  DISABLED_ShouldAggressivelyFreeResources
+#else
+#define MAYBE_ShouldAggressivelyFreeResources ShouldAggressivelyFreeResources
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_ShouldAggressivelyFreeResources) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   sk_sp<SkImage> image = CreateImage(100, 100);
   DrawImage draw_image(image, SkIRect::MakeWH(image->width(), image->height()),
                        quality,
                        CreateMatrix(SkSize::Make(0.5f, 0.5f), is_decomposable),
@@ skipping 43 matching lines @@
     EXPECT_TRUE(task);
 
     TestTileTaskRunner::ProcessTask(task->dependencies()[0].get());
     TestTileTaskRunner::ProcessTask(task.get());
     cache.UnrefImage(draw_image);
 
     EXPECT_GT(cache.GetBytesUsedForTesting(), 0u);
   }
 }
 
-TEST(GpuImageDecodeCacheTest, OrphanedImagesFreeOnReachingZeroRefs) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_OrphanedImagesFreeOnReachingZeroRefs \
+  DISABLED_OrphanedImagesFreeOnReachingZeroRefs
+#else
+#define MAYBE_OrphanedImagesFreeOnReachingZeroRefs \
+  OrphanedImagesFreeOnReachingZeroRefs
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_OrphanedImagesFreeOnReachingZeroRefs) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Create a downscaled image.
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
@@ skipping 36 matching lines @@
   // deleted.
   TestTileTaskRunner::ProcessTask(first_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(first_task.get());
   cache.UnrefImage(first_draw_image);
 
   // The budget should account for exactly one image.
   EXPECT_EQ(cache.GetBytesUsedForTesting(),
             cache.GetDrawImageSizeForTesting(second_draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, OrphanedZeroRefImagesImmediatelyDeleted) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_OrphanedZeroRefImagesImmediatelyDeleted \
+  DISABLED_OrphanedZeroRefImagesImmediatelyDeleted
+#else
+#define MAYBE_OrphanedZeroRefImagesImmediatelyDeleted \
+  OrphanedZeroRefImagesImmediatelyDeleted
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_OrphanedZeroRefImagesImmediatelyDeleted) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   bool is_decomposable = true;
   SkFilterQuality quality = kHigh_SkFilterQuality;
 
   // Create a downscaled image.
   sk_sp<SkImage> first_image = CreateImage(100, 100);
   DrawImage first_draw_image(
       first_image, SkIRect::MakeWH(first_image->width(), first_image->height()),
@@ skipping 29 matching lines @@
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(second_draw_image);
 
   // The budget should account for exactly one image.
   EXPECT_EQ(cache.GetBytesUsedForTesting(),
             cache.GetDrawImageSizeForTesting(second_draw_image));
 }
 
-TEST(GpuImageDecodeCacheTest, QualityCappedAtMedium) {
+// crbug.com/697171.
+#if defined(MEMORY_SANITIZER)
+#define MAYBE_QualityCappedAtMedium DISABLED_QualityCappedAtMedium
+#else
+#define MAYBE_QualityCappedAtMedium QualityCappedAtMedium
+#endif
+TEST(GpuImageDecodeCacheTest, MAYBE_QualityCappedAtMedium) {
   auto context_provider = TestContextProvider::Create();
   context_provider->BindToCurrentThread();
   TestGpuImageDecodeCache cache(context_provider.get());
   sk_sp<SkImage> image = CreateImage(100, 100);
   bool is_decomposable = true;
   SkMatrix matrix = CreateMatrix(SkSize::Make(0.4f, 0.4f), is_decomposable);
 
   // Create an image with kLow_FilterQuality.
   DrawImage low_draw_image(image,
                            SkIRect::MakeWH(image->width(), image->height()),
@@ skipping 405 matching lines @@
   TestTileTaskRunner::ProcessTask(second_task->dependencies()[0].get());
   TestTileTaskRunner::ProcessTask(second_task.get());
 
   cache.UnrefImage(first_draw_image);
   cache.UnrefImage(second_draw_image);
   cache.UnrefImage(third_draw_image);
 }
 
 }  // namespace
 }  // namespace cc