TestingPlatformSupport: register Platform instance correctly

third_party/WebKit/Source/platform/testing/TestingPlatformSupport.h

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #ifndef TestingPlatformSupport_h
 #define TestingPlatformSupport_h
 
 #include "platform/PlatformExport.h"
 #include "platform/WebTaskRunner.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "public/platform/WebScheduler.h"
 #include "public/platform/WebThread.h"
+#include "wtf/Allocator.h"
+#include "wtf/Assertions.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <memory>
+#include <utility>
 
 namespace base {
 class SimpleTestTickClock;
 class TestDiscardableMemoryAllocator;
 }
 
 namespace cc {
 class OrderedSimpleTaskRunner;
 }
 
@@ skipping 48 matching lines @@
       InterventionReporter*,
       WebViewScheduler::WebViewSchedulerSettings*) override {
     return nullptr;
   }
   void suspendTimerQueue() override {}
   void resumeTimerQueue() override {}
   void addPendingNavigation(WebScheduler::NavigatingFrameType) override {}
   void removePendingNavigation(WebScheduler::NavigatingFrameType) override {}
 };
 
+// A base class to override Platform methods for testing.  You can override
+// compositorSupport() method via a TestingPlatformSupport::Config parameter.
+// Other virtual Platform methods that are overriden in this class will call
+// the original Platform methods that can be obtained by Platform::current()
+// in the consturctor.
+// Or you may to consider to implement your own inheritance of this class to
+// override arbitorary virtual methods.
+// You should use ScopedTestingPlatformSupport to hold any instance of this
+// class and inheritances in order to setup and shutdown Platform instance
+// correctly.  See also comments on ScopedTestingPlatformSupport.

[haraken, 2017/01/12 11:21:01]

Slightly simpler:

// A base class to override Platform methods for testing. You can override the
behavior by subclassing TestingPlatformSupport or using
ScopedTestingPlatformSupport (see below).

(I'm wondering why compositorSupport is handled specially.)

[Takashi Toyoshima, 2017/01/12 12:13:01]

Actually, existing TestingPlatformSupport and
TestingPlatformSupportWithMockScheduler can take a Config parameter in
constructors so that users can override compositorSupport behavior.

I think the original author intended that Config is used for overriding
stateless behavior like just returning preallocated object like
compositorSupport, and otherwise we can subclass this for introducing stateful
logic.

But anyway, I'd adopt your simple explanation here.

 class TestingPlatformSupport : public Platform {
   WTF_MAKE_NONCOPYABLE(TestingPlatformSupport);
 
  public:
   struct Config {
     WebCompositorSupport* compositorSupport = nullptr;
   };
 
   TestingPlatformSupport();
   explicit TestingPlatformSupport(const Config&);
@@ skipping 15 matching lines @@
   InterfaceProvider* interfaceProvider() override;
 
  protected:
   class TestingInterfaceProvider;
 
   const Config m_config;
   Platform* const m_oldPlatform;
   std::unique_ptr<TestingInterfaceProvider> m_interfaceProvider;
 };
 
+// This class adds mocked scheduler support to TestingPlatformSupport.  See also
+// comments on TestingPlatformSupport to use this class correctly.
 class TestingPlatformSupportWithMockScheduler : public TestingPlatformSupport {
   WTF_MAKE_NONCOPYABLE(TestingPlatformSupportWithMockScheduler);
 
  public:
   TestingPlatformSupportWithMockScheduler();
   explicit TestingPlatformSupportWithMockScheduler(const Config&);
   ~TestingPlatformSupportWithMockScheduler() override;
 
   // Platform:
   WebThread* currentThread() override;
@@ skipping 26 matching lines @@
 
  protected:
   static double getTestTime();
 
   std::unique_ptr<base::SimpleTestTickClock> m_clock;
   scoped_refptr<cc::OrderedSimpleTaskRunner> m_mockTaskRunner;
   std::unique_ptr<scheduler::RendererSchedulerImpl> m_scheduler;
   std::unique_ptr<WebThread> m_thread;
 };
 
-class ScopedUnittestsEnvironmentSetup {
+// A template class to hold an instance of TestingPlatformSupport class and
+// inheritances.  This class also sets up the instance to be available through
+// Platform::current(), and safely reset it to the previous Platform instance
+// on its destruction.  Instances could be nested.

[haraken, 2017/01/12 11:21:01]

Slightly simpler:

// ScopedTestingPlatformSupport<MyTestingPlatformSupport> can be used to
override Platform::current() with MyTestingPlatformSupport, like this:

[Takashi Toyoshima, 2017/01/12 12:13:01]

Done.

+//
+// Usage:
+//
+// #include "platform/testing/TestingPlatformSupport.h"
+//
+// TEST_F(SampleTest, sampleTest) {
+//   ScopedTestingPlatformSupport<MyTestingPlatformSupport> platform;
+//   ...
+//   // You can call methods of MyTestingPlatformSupport.
+//   EXPECT_TRUE(platform->myMethodIsCalled());
+//
+//   // Another instance can be nested.
+//   {
+//     // Constructor's arguments can be passed like this.
+//     Arg arg;
+//     ScopedTestingPlatformSupport<MyAnotherTestingPlatformSupport, const Arg&>
+//         another_platform(args);
+//     ...
+//   }
+//
+//   // Here the origianl MyTestingPlatformSupport should be restored.

[haraken, 2017/01/12 11:21:01]

original

[Takashi Toyoshima, 2017/01/12 12:13:02]

Done.

+// }
+template <class T, typename... Args>
+class ScopedTestingPlatformSupport final {

[haraken, 2017/01/12 11:21:01]

This looks much simpler!

[Takashi Toyoshima, 2017/01/12 12:13:01]

Acknowledged.

+  STACK_ALLOCATED();
+
+ public:
+  explicit ScopedTestingPlatformSupport(Args&&... args) {
+    m_testingPlatformSupport = WTF::makeUnique<T>(std::forward<Args>(args)...);
+    m_originalPlatform = Platform::current();
+    DCHECK(m_originalPlatform);
+    Platform::setCurrentPlatformForTesting(m_testingPlatformSupport.get());
+  }
+  ~ScopedTestingPlatformSupport() {
+    DCHECK_EQ(m_testingPlatformSupport.get(), Platform::current());
+    m_testingPlatformSupport.reset();
+    Platform::setCurrentPlatformForTesting(m_originalPlatform);
+  }
+
+  const T* operator->() const { return m_testingPlatformSupport.get(); }
+  T* operator->() { return m_testingPlatformSupport.get(); }
+
+ private:
+  std::unique_ptr<T> m_testingPlatformSupport;
+  Platform* m_originalPlatform;
+};
+
+class ScopedUnittestsEnvironmentSetup final {
   WTF_MAKE_NONCOPYABLE(ScopedUnittestsEnvironmentSetup);
 
  public:
   ScopedUnittestsEnvironmentSetup(int argc, char** argv);
   ~ScopedUnittestsEnvironmentSetup();
 
  private:
   class DummyPlatform;
   std::unique_ptr<base::TestDiscardableMemoryAllocator>
       m_discardableMemoryAllocator;
-  std::unique_ptr<DummyPlatform> m_platform;
+  std::unique_ptr<DummyPlatform> m_dummyPlatform;
   std::unique_ptr<cc_blink::WebCompositorSupportImpl> m_compositorSupport;
   TestingPlatformSupport::Config m_testingPlatformConfig;
   std::unique_ptr<TestingPlatformSupport> m_testingPlatformSupport;
 };
 
 }  // namespace blink
 
 #endif  // TestingPlatformSupport_h