content/renderer/render_thread_impl_browsertest.cc

   1 // Copyright 2013 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 "base/callback.h"
   6 #include "base/command_line.h"
   7 #include "base/memory/discardable_memory.h"
   8 #include "base/memory/scoped_vector.h"
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/thread_task_runner_handle.h"
  11 #include "content/common/resource_messages.h"
  12 #include "content/common/websocket_messages.h"
  13 #include "content/public/browser/content_browser_client.h"
  14 #include "content/public/common/content_client.h"
  15 #include "content/public/common/content_switches.h"
  16 #include "content/public/renderer/content_renderer_client.h"
  17 #include "content/renderer/render_process_impl.h"
  18 #include "content/renderer/render_thread_impl.h"
  19 #include "content/test/mock_render_process.h"
  20 #include "content/test/render_thread_impl_browser_test_ipc_helper.h"
  21 #include "gpu/GLES2/gl2extchromium.h"
  22 #include "testing/gtest/include/gtest/gtest.h"
  23
  24 // IPC messages for testing ----------------------------------------------------
  25
  26 #define IPC_MESSAGE_IMPL
  27 #include "ipc/ipc_message_macros.h"
  28
  29 #undef IPC_MESSAGE_START
  30 #define IPC_MESSAGE_START TestMsgStart
  31 IPC_MESSAGE_CONTROL0(TestMsg_QuitRunLoop)
  32
  33 // -----------------------------------------------------------------------------
  34
  35 // These tests leak memory, this macro disables the test when under the
  36 // LeakSanitizer.
  37 #ifdef LEAK_SANITIZER
  38 #define WILL_LEAK(NAME) DISABLED_##NAME
  39 #else
  40 #define WILL_LEAK(NAME) NAME
  41 #endif
  42
  43 namespace content {
  44 namespace {
  45
  46 // FIXME: It would be great if there was a reusable mock SingleThreadTaskRunner
  47 class TestTaskCounter : public base::SingleThreadTaskRunner {
  48  public:
  49   TestTaskCounter() : count_(0) {}
  50
  51   // SingleThreadTaskRunner implementation.
  52   bool PostDelayedTask(const tracked_objects::Location&,
  53                        const base::Closure&,
  54                        base::TimeDelta) override {
  55     base::AutoLock auto_lock(lock_);
  56     count_++;
  57     return true;
  58   }
  59
  60   bool PostNonNestableDelayedTask(const tracked_objects::Location&,
  61                                   const base::Closure&,
  62                                   base::TimeDelta) override {
  63     base::AutoLock auto_lock(lock_);
  64     count_++;
  65     return true;
  66   }
  67
  68   bool RunsTasksOnCurrentThread() const override { return true; }
  69
  70   int NumTasksPosted() const {
  71     base::AutoLock auto_lock(lock_);
  72     return count_;
  73   }
  74
  75  private:
  76   ~TestTaskCounter() override {}
  77
  78   mutable base::Lock lock_;
  79   int count_;
  80 };
  81
  82 #if defined(COMPILER_MSVC)
  83 // See explanation for other RenderViewHostImpl which is the same issue.
  84 #pragma warning(push)
  85 #pragma warning(disable: 4250)
  86 #endif
  87
  88 class RenderThreadImplForTest : public RenderThreadImpl {
  89  public:
  90   RenderThreadImplForTest(const std::string& channel_id,
  91                           scoped_refptr<TestTaskCounter> test_task_counter)
  92       : RenderThreadImpl(channel_id), test_task_counter_(test_task_counter) {}
  93
  94   ~RenderThreadImplForTest() override {}
  95
  96   void SetResourceDispatchTaskQueue(
  97       const scoped_refptr<base::SingleThreadTaskRunner>&) override {
  98     // Use our TestTaskCounter instead.
  99     RenderThreadImpl::SetResourceDispatchTaskQueue(test_task_counter_);
 100   }
 101
 102   using ChildThreadImpl::OnMessageReceived;
 103
 104  private:
 105   scoped_refptr<TestTaskCounter> test_task_counter_;
 106 };
 107
 108 #if defined(COMPILER_MSVC)
 109 #pragma warning(pop)
 110 #endif
 111
 112 void QuitTask(base::MessageLoop* message_loop) {
 113   message_loop->QuitWhenIdle();
 114 }
 115
 116 class QuitOnTestMsgFilter : public IPC::MessageFilter {
 117  public:
 118   explicit QuitOnTestMsgFilter(base::MessageLoop* message_loop)
 119       : message_loop_(message_loop) {}
 120
 121   // IPC::MessageFilter overrides:
 122   bool OnMessageReceived(const IPC::Message& message) override {
 123     message_loop_->PostTask(FROM_HERE, base::Bind(&QuitTask, message_loop_));
 124     return true;
 125   }
 126
 127   bool GetSupportedMessageClasses(
 128       std::vector<uint32>* supported_message_classes) const override {
 129     supported_message_classes->push_back(TestMsgStart);
 130     return true;
 131   }
 132
 133  private:
 134   ~QuitOnTestMsgFilter() override {}
 135
 136   base::MessageLoop* message_loop_;
 137 };
 138
 139 class RenderThreadImplBrowserTest : public testing::Test {
 140  public:
 141   void SetUp() override {
 142     content_client_.reset(new ContentClient());
 143     content_browser_client_.reset(new ContentBrowserClient());
 144     content_renderer_client_.reset(new ContentRendererClient());
 145     SetContentClient(content_client_.get());
 146     SetBrowserClientForTesting(content_browser_client_.get());
 147     SetRendererClientForTesting(content_renderer_client_.get());
 148
 149     test_helper_.reset(new RenderThreadImplBrowserIPCTestHelper());
 150
 151     mock_process_.reset(new MockRenderProcess);
 152     test_task_counter_ = make_scoped_refptr(new TestTaskCounter());
 153
 154     // RenderThreadImpl expects the browser to pass these flags.
 155     base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 156     base::CommandLine::StringVector old_argv = cmd->argv();
 157
 158     cmd->AppendSwitchASCII(switches::kNumRasterThreads, "1");
 159     cmd->AppendSwitchASCII(switches::kUseImageTextureTarget,
 160                            base::UintToString(GL_TEXTURE_2D));
 161
 162     thread_ = new RenderThreadImplForTest(test_helper_->GetChannelId(),
 163                                           test_task_counter_);
 164     cmd->InitFromArgv(old_argv);
 165
 166     thread_->EnsureWebKitInitialized();
 167
 168     test_msg_filter_ = make_scoped_refptr(
 169         new QuitOnTestMsgFilter(test_helper_->GetMessageLoop()));
 170     thread_->AddFilter(test_msg_filter_.get());
 171   }
 172
 173   scoped_refptr<TestTaskCounter> test_task_counter_;
 174   scoped_ptr<ContentClient> content_client_;
 175   scoped_ptr<ContentBrowserClient> content_browser_client_;
 176   scoped_ptr<ContentRendererClient> content_renderer_client_;
 177   scoped_ptr<RenderThreadImplBrowserIPCTestHelper> test_helper_;
 178   scoped_ptr<MockRenderProcess> mock_process_;
 179   scoped_refptr<QuitOnTestMsgFilter> test_msg_filter_;
 180   RenderThreadImplForTest* thread_;  // Owned by mock_process_.
 181   std::string channel_id_;
 182 };
 183
 184 void CheckRenderThreadInputHandlerManager(RenderThreadImpl* thread) {
 185   ASSERT_TRUE(thread->input_handler_manager());
 186 }
 187
 188 // Check that InputHandlerManager outlives compositor thread because it uses
 189 // raw pointers to post tasks.
 190 // Disabled under LeakSanitizer due to memory leaks. http://crbug.com/348994
 191 TEST_F(RenderThreadImplBrowserTest,
 192        WILL_LEAK(InputHandlerManagerDestroyedAfterCompositorThread)) {
 193   ASSERT_TRUE(thread_->input_handler_manager());
 194
 195   thread_->compositor_message_loop_proxy()->PostTask(
 196       FROM_HERE, base::Bind(&CheckRenderThreadInputHandlerManager, thread_));
 197 }
 198
 199 // Checks that emulated discardable memory is discarded when the last widget
 200 // is hidden.
 201 // Disabled under LeakSanitizer due to memory leaks.
 202 TEST_F(RenderThreadImplBrowserTest,
 203        WILL_LEAK(EmulatedDiscardableMemoryDiscardedWhenWidgetsHidden)) {
 204   thread_->WidgetCreated();
 205
 206   // Allocate 128MB of discardable memory.
 207   ScopedVector<base::DiscardableMemory> discardable_memory;
 208   for (int i = 0; i < 32; ++i) {
 209     discardable_memory.push_back(
 210         base::DiscardableMemory::CreateLockedMemoryWithType(
 211             base::DISCARDABLE_MEMORY_TYPE_EMULATED, 4 * 1024 * 1024).release());
 212     ASSERT_TRUE(discardable_memory.back());
 213     discardable_memory.back()->Unlock();
 214   }
 215
 216   // Hide all widgets.
 217   thread_->WidgetHidden();
 218
 219   // Count how much memory is left, should be at most one block.
 220   int blocks_left = 0;
 221   for (auto iter = discardable_memory.begin(); iter != discardable_memory.end();
 222        ++iter) {
 223     if ((*iter)->Lock() == base::DISCARDABLE_MEMORY_LOCK_STATUS_SUCCESS)
 224       ++blocks_left;
 225   }
 226   EXPECT_LE(blocks_left, 1);
 227
 228   thread_->WidgetDestroyed();
 229 }
 230
 231 // Disabled under LeakSanitizer due to memory leaks.
 232 TEST_F(RenderThreadImplBrowserTest,
 233        WILL_LEAK(ResourceDispatchIPCTasksGoThroughScheduler)) {
 234   test_helper_->Sender()->Send(new ResourceHostMsg_FollowRedirect(0));
 235   test_helper_->Sender()->Send(new TestMsg_QuitRunLoop());
 236
 237   test_helper_->GetMessageLoop()->Run();
 238   EXPECT_EQ(1, test_task_counter_->NumTasksPosted());
 239 }
 240
 241 // Disabled under LeakSanitizer due to memory leaks.
 242 TEST_F(RenderThreadImplBrowserTest,
 243        WILL_LEAK(NonResourceDispatchIPCTasksDontGoThroughScheduler)) {
 244   // NOTE other than not being a resource message, the actual message is
 245   // unimportant.
 246   test_helper_->Sender()->Send(new WebSocketMsg_NotifyFailure(1, ""));
 247   test_helper_->Sender()->Send(new TestMsg_QuitRunLoop());
 248
 249   test_helper_->GetMessageLoop()->Run();
 250
 251   EXPECT_EQ(0, test_task_counter_->NumTasksPosted());
 252 }
 253
 254 }  // namespace
 255 }  // namespace content