Allow explicitly whitelisted apps/extensions in public sessions

content/public/test/test_utils.h

 // Copyright (c) 2012 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_PUBLIC_TEST_TEST_UTILS_H_
 #define CONTENT_PUBLIC_TEST_TEST_UTILS_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 82 matching lines @@
 
 // A WindowedNotificationObserver allows code to wait until a condition is met.
 // Simple conditions are specified by providing a |notification_type| and a
 // |source|. When a notification of the expected type from the expected source
 // is received, the condition is met.
 // More complex conditions can be specified by providing a |notification_type|
 // and a |callback|. The callback is called whenever the notification is fired.
 // If the callback returns |true|, the condition is met. Otherwise, the
 // condition is not yet met and the callback will be invoked again every time a
 // notification of the expected type is received until the callback returns
-// |true|.
+// |true|. For convenience, two callback types are defined, one that is provided
+// with the notification source and details, and one that is not.
 //
 // This helper class exists to avoid the following common pattern in tests:
 //   PerformAction()
 //   WaitForCompletionNotification()
 // The pattern leads to flakiness as there is a window between PerformAction
 // returning and the observers getting registered, where a notification will be
 // missed.
 //
 // Rather, one can do this:
 //   WindowedNotificationObserver signal(...)
 //   PerformAction()
 //   signal.Wait()
 class WindowedNotificationObserver : public NotificationObserver {
  public:
   // Callback invoked on notifications. Should return |true| when the condition
-  // being waited for is met.
-  typedef base::Callback<bool(void)> ConditionTestCallback;
+  // being waited for is met. For convenience, there is a choice between two
+  // callback types, one that is provided with the notification source and
+  // details, and one that is not.
+  typedef base::Callback<bool(const NotificationSource&,
+                              const NotificationDetails&)>
+      ConditionTestCallback;
+  typedef base::Callback<bool(void)>
+      ConditionTestCallbackWithoutSourceAndDetails;
 
   // Set up to wait for a simple condition. The condition is met when a
   // notification of the given |notification_type| from the given |source| is
   // received. To accept notifications from all sources, specify
   // NotificationService::AllSources() as |source|.
   WindowedNotificationObserver(int notification_type,
                                const NotificationSource& source);
 
   // Set up to wait for a complex condition. The condition is met when
   // |callback| returns |true|. The callback is invoked whenever a notification
   // of |notification_type| from any source is received.
   WindowedNotificationObserver(int notification_type,
                                const ConditionTestCallback& callback);
+  WindowedNotificationObserver(
+      int notification_type,
+      const ConditionTestCallbackWithoutSourceAndDetails& callback);
 
   virtual ~WindowedNotificationObserver();
 
   // Wait until the specified condition is met. If the condition is already met
   // (that is, the expected notification has already been received or the
   // given callback returns |true| already), Wait() returns immediately.
   void Wait();
 
   // Returns NotificationService::AllSources() if we haven't observed a
   // notification yet.
@@ skipping 20 matching lines @@
   NotificationSource source_;
   NotificationDetails details_;
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowedNotificationObserver);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_TEST_TEST_UTILS_H_