chrome/browser/bitmap_fetcher_browsertest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/bitmap_fetcher.h"
   6
   7 #include "base/compiler_specific.h"
   8 #include "chrome/browser/profiles/profile.h"
   9 #include "chrome/browser/ui/browser.h"
  10 #include "chrome/test/base/in_process_browser_test.h"
  11 #include "content/public/test/test_utils.h"
  12 #include "net/base/load_flags.h"
  13 #include "net/http/http_status_code.h"
  14 #include "net/url_request/test_url_fetcher_factory.h"
  15 #include "net/url_request/url_fetcher.h"
  16 #include "net/url_request/url_request_status.h"
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "third_party/skia/include/core/SkBitmap.h"
  19 #include "ui/gfx/codec/png_codec.h"
  20 #include "ui/gfx/size.h"
  21 #include "ui/gfx/skia_util.h"
  22
  23 namespace {
  24 const bool kAsyncCall = true;
  25 const bool kSyncCall = false;
  26 }  // namespace
  27
  28 namespace chrome {
  29
  30 // Class to catch events from the BitmapFetcher for testing.
  31 class BitmapFetcherTestDelegate : public BitmapFetcherDelegate {
  32  public:
  33   explicit BitmapFetcherTestDelegate(bool async)
  34       : called_(false), success_(false), async_(async) {}
  35
  36   virtual ~BitmapFetcherTestDelegate() { EXPECT_TRUE(called_); }
  37
  38   // Method inherited from BitmapFetcherDelegate.
  39   virtual void OnFetchComplete(const GURL url,
  40                                const SkBitmap* bitmap) OVERRIDE {
  41     called_ = true;
  42     url_ = url;
  43     if (NULL != bitmap) {
  44       success_ = true;
  45       bitmap->deepCopyTo(&bitmap_);
  46     }
  47     // For async calls, we need to quit the message loop so the test can
  48     // continue.
  49     if (async_) {
  50       base::MessageLoop::current()->Quit();
  51     }
  52   }
  53
  54   GURL url() const { return url_; }
  55   bool success() const { return success_; }
  56   const SkBitmap& bitmap() const { return bitmap_; }
  57
  58  private:
  59   bool called_;
  60   GURL url_;
  61   bool success_;
  62   bool async_;
  63   SkBitmap bitmap_;
  64
  65   DISALLOW_COPY_AND_ASSIGN(BitmapFetcherTestDelegate);
  66 };
  67
  68 class BitmapFetcherBrowserTest : public InProcessBrowserTest {
  69  public:
  70   virtual void SetUp() OVERRIDE {
  71     url_fetcher_factory_.reset(new net::FakeURLFetcherFactory(NULL));
  72     InProcessBrowserTest::SetUp();
  73   }
  74
  75  protected:
  76   scoped_ptr<net::FakeURLFetcherFactory> url_fetcher_factory_;
  77 };
  78
  79 #if defined(OS_WIN)
  80 #define MAYBE_StartTest DISABLED_StartTest
  81 #else
  82 #define MAYBE_StartTest StartTest
  83 #endif
  84
  85 // WARNING:  These tests work with --single_process, but not
  86 // --single-process.  The reason is that the sandbox does not get created
  87 // for us by the test process if --single-process is used.
  88
  89 IN_PROC_BROWSER_TEST_F(BitmapFetcherBrowserTest, MAYBE_StartTest) {
  90   GURL url("http://example.com/this-should-work");
  91
  92   // Put some realistic looking bitmap data into the url_fetcher.
  93   SkBitmap image;
  94
  95   // Put a real bitmap into "image".  2x2 bitmap of green 32 bit pixels.
  96   image.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
  97   image.allocPixels();
  98   image.eraseColor(SK_ColorGREEN);
  99
 100   // Encode the bits as a PNG.
 101   std::vector<unsigned char> compressed;
 102   ASSERT_TRUE(gfx::PNGCodec::EncodeBGRASkBitmap(image, true, &compressed));
 103
 104   // Copy the bits into the string, and put them into the FakeURLFetcher.
 105   std::string image_string(compressed.begin(), compressed.end());
 106
 107   // Set up a delegate to wait for the callback.
 108   BitmapFetcherTestDelegate delegate(kAsyncCall);
 109
 110   BitmapFetcher fetcher(url, &delegate);
 111
 112   url_fetcher_factory_->SetFakeResponse(
 113       url, image_string, net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 114
 115   // We expect that the image decoder will get called and return
 116   // an image in a callback to OnImageDecoded().
 117   fetcher.Start(
 118       browser()->profile()->GetRequestContext(),
 119       std::string(),
 120       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
 121       net::LOAD_NORMAL);
 122
 123   // Blocks until test delegate is notified via a callback.
 124   content::RunMessageLoop();
 125
 126   ASSERT_TRUE(delegate.success());
 127
 128   // Make sure we get back the bitmap we expect.
 129   const SkBitmap& found_image = delegate.bitmap();
 130   EXPECT_TRUE(gfx::BitmapsAreEqual(image, found_image));
 131 }
 132
 133 IN_PROC_BROWSER_TEST_F(BitmapFetcherBrowserTest, OnImageDecodedTest) {
 134   GURL url("http://example.com/this-should-work-as-well");
 135   SkBitmap image;
 136
 137   // Put a real bitmap into "image".  2x2 bitmap of green 16 bit pixels.
 138   image.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
 139   image.allocPixels();
 140   image.eraseColor(SK_ColorGREEN);
 141
 142   BitmapFetcherTestDelegate delegate(kSyncCall);
 143
 144   BitmapFetcher fetcher(url, &delegate);
 145
 146   fetcher.OnImageDecoded(NULL, image);
 147
 148   // Ensure image is marked as succeeded.
 149   EXPECT_TRUE(delegate.success());
 150
 151   // Test that the image is what we expect.
 152   EXPECT_TRUE(gfx::BitmapsAreEqual(image, delegate.bitmap()));
 153 }
 154
 155 IN_PROC_BROWSER_TEST_F(BitmapFetcherBrowserTest, OnURLFetchFailureTest) {
 156   GURL url("http://example.com/this-should-be-fetch-failure");
 157
 158   // We intentionally put no data into the bitmap to simulate a failure.
 159
 160   // Set up a delegate to wait for the callback.
 161   BitmapFetcherTestDelegate delegate(kAsyncCall);
 162
 163   BitmapFetcher fetcher(url, &delegate);
 164
 165   url_fetcher_factory_->SetFakeResponse(url,
 166                                         std::string(),
 167                                         net::HTTP_INTERNAL_SERVER_ERROR,
 168                                         net::URLRequestStatus::FAILED);
 169
 170   fetcher.Start(
 171       browser()->profile()->GetRequestContext(),
 172       std::string(),
 173       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
 174       net::LOAD_NORMAL);
 175
 176   // Blocks until test delegate is notified via a callback.
 177   content::RunMessageLoop();
 178
 179   EXPECT_FALSE(delegate.success());
 180 }
 181
 182 // Flaky on Win XP Debug: crbug.com/316488
 183 #if defined(OS_WIN) && !defined(NDEBUG)
 184 #define MAYBE_HandleImageFailedTest DISABLED_HandleImageFailedTest
 185 #else
 186 #define MAYBE_HandleImageFailedTest HandleImageFailedTest
 187 #endif
 188
 189 IN_PROC_BROWSER_TEST_F(BitmapFetcherBrowserTest, MAYBE_HandleImageFailedTest) {
 190   GURL url("http://example.com/this-should-be-a-decode-failure");
 191   BitmapFetcherTestDelegate delegate(kAsyncCall);
 192   BitmapFetcher fetcher(url, &delegate);
 193   url_fetcher_factory_->SetFakeResponse(url,
 194                                         std::string("Not a real bitmap"),
 195                                         net::HTTP_OK,
 196                                         net::URLRequestStatus::SUCCESS);
 197
 198   fetcher.Start(
 199       browser()->profile()->GetRequestContext(),
 200       std::string(),
 201       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
 202       net::LOAD_NORMAL);
 203
 204   // Blocks until test delegate is notified via a callback.
 205   content::RunMessageLoop();
 206
 207   EXPECT_FALSE(delegate.success());
 208 }
 209
 210 }  // namespace chrome