[ServiceWorker] Mojofy ActivateEvent of Service Worker

content/browser/service_worker/embedded_worker_test_helper.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 47 matching lines @@
 // also returns success for event messages (e.g. InstallEvent, FetchEvent).
 //
 // Alternatively consumers can subclass this helper and override On*()
 // methods to add their own logic/verification code.
 //
 // See embedded_worker_instance_unittest.cc for example usages.
 //
 class EmbeddedWorkerTestHelper : public IPC::Sender,
                                  public IPC::Listener {
  public:
+  enum class Event { Activate };
   using FetchCallback =
       base::Callback<void(ServiceWorkerStatusCode,
                           base::Time /* dispatch_event_time */)>;
+  const std::vector<Event>& dispatched_events() const { return events_; }

[Peter Beverloo, 2017/02/14 15:48:13]

nit: this should be next to the other getters around line 132

[xiaofengzhang, 2017/02/15 01:59:45]

Acknowledged.

[xiaofengzhang, 2017/02/15 06:14:44]

Done.

 
   class MockEmbeddedWorkerInstanceClient
       : public mojom::EmbeddedWorkerInstanceClient {
    public:
     explicit MockEmbeddedWorkerInstanceClient(
         base::WeakPtr<EmbeddedWorkerTestHelper> helper);
     ~MockEmbeddedWorkerInstanceClient() override;
 
     static void Bind(const base::WeakPtr<EmbeddedWorkerTestHelper>& helper,
                      mojom::EmbeddedWorkerInstanceClientRequest request);
@@ skipping 95 matching lines @@
   // The legacy IPC message handler. This passes the messages to their
   // respective On*Event handler by default.
   virtual bool OnMessageToWorker(int thread_id,
                                  int embedded_worker_id,
                                  const IPC::Message& message);
 
   // On*Event handlers. Called by the default implementation of
   // OnMessageToWorker when events are sent to the embedded
   // worker. By default they just return success via
   // SimulateSendReplyToBrowser.
-  virtual void OnActivateEvent(int embedded_worker_id, int request_id);
+  virtual void OnActivateEvent(
+      const mojom::ServiceWorkerEventDispatcher::DispatchActivateEventCallback&
+          callback);
   virtual void OnExtendableMessageEvent(
       mojom::ExtendableMessageEventPtr event,
       const mojom::ServiceWorkerEventDispatcher::
           DispatchExtendableMessageEventCallback& callback);
   virtual void OnInstallEvent(int embedded_worker_id, int request_id);
   virtual void OnFetchEvent(int embedded_worker_id,
                             int fetch_event_id,
                             const ServiceWorkerFetchRequest& request,
                             mojom::FetchEventPreloadHandlePtr preload_handle,
                             const FetchCallback& callback);
@@ skipping 23 matching lines @@
   void SimulateWorkerReadyForInspection(int embedded_worker_id);
   void SimulateWorkerScriptCached(int embedded_worker_id);
   void SimulateWorkerScriptLoaded(int embedded_worker_id);
   void SimulateWorkerThreadStarted(int thread_id, int embedded_worker_id);
   void SimulateWorkerScriptEvaluated(int embedded_worker_id, bool success);
   void SimulateWorkerStarted(int embedded_worker_id);
   void SimulateWorkerStopped(int embedded_worker_id);
   void SimulateSend(IPC::Message* message);
 
   EmbeddedWorkerRegistry* registry();
+  std::vector<Event> events_;

[Peter Beverloo, 2017/02/14 15:48:13]

This has to be with the other members, probably after line 316.

[shimazu, 2017/02/15 01:29:02]

+1 for moving; this should be private.

[xiaofengzhang, 2017/02/15 01:59:45]

Acknowledged.

[xiaofengzhang, 2017/02/15 02:15:30]

sorry, it should be not private, because it will be used in line 103 of
service_worker_context_unittest.cc

[shimazu, 2017/02/15 02:30:11]

Ah, I see. How about protected for |events_| instead?

[xiaofengzhang, 2017/02/15 02:39:30]

yeah, here is already protected, do you think ok? :-)

[falken, 2017/02/15 03:13:24]

Technically by the style guide this must be private:
https://google.github.io/styleguide/cppguide.html#Access_Control

You can add a public or protected method for access to events, e.g., AddEvent.
Or if we really need access just return a pointer to events.

[shimazu, 2017/02/15 03:14:54]

Oops, sorry. Yes, it's good:)

nit: could you add a break line before this member variable?

[xiaofengzhang, 2017/02/15 06:14:44]

Done.

 
  private:
   class MockServiceWorkerEventDispatcher;
 
   void OnStartWorkerStub(const EmbeddedWorkerStartParams& params,
                          mojom::ServiceWorkerEventDispatcherRequest request);
   void OnResumeAfterDownloadStub(int embedded_worker_id);
   void OnStopWorkerStub(
       const mojom::EmbeddedWorkerInstanceClient::StopWorkerCallback& callback);
   void OnMessageToWorkerStub(int thread_id,
                              int embedded_worker_id,
                              const IPC::Message& message);
-  void OnActivateEventStub(int request_id);
+  void OnActivateEventStub(
+      const mojom::ServiceWorkerEventDispatcher::DispatchActivateEventCallback&
+          callback);
   void OnExtendableMessageEventStub(
       mojom::ExtendableMessageEventPtr event,
       const mojom::ServiceWorkerEventDispatcher::
           DispatchExtendableMessageEventCallback& callback);
   void OnInstallEventStub(int request_id);
   void OnFetchEventStub(int thread_id,
                         int fetch_event_id,
                         const ServiceWorkerFetchRequest& request,
                         mojom::FetchEventPreloadHandlePtr preload_handle,
                         const FetchCallback& callback);
@@ skipping 66 matching lines @@
   std::unique_ptr<MockType> mock =
       base::MakeUnique<MockType>(std::forward<Args>(args)...);
   MockType* mock_rawptr = mock.get();
   RegisterMockInstanceClient(std::move(mock));
   return mock_rawptr;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_EMBEDDED_WORKER_TEST_HELPER_H_