[iOS] Created bridge class for ChromeBroadcastObserver.

This CL adds ChromeBroadcastObserverBridge, which allows C++ objects to
register as observers for broadcasted UI state.

Bug: 785663
Cq-Include-Trybots: master.tryserver.chromium.mac:ios-simulator-cronet;master.tryserver.chromium.mac:ios-simulator-full-configs
Change-Id: I5ee8ffdfd2173a8a57b16e0e2ad9d1634dcbd4ea
Reviewed-on: https://chromium-review.googlesource.com/780810
Commit-Queue: Kurt Horimoto <kkhorimoto@chromium.org>
Reviewed-by: Mark Cogan <marq@chromium.org>
Cr-Commit-Position: refs/heads/master@{#519811}

ios/chrome/browser/ui/broadcaster/BUILD.gn

@@ -5,6 +5,8 @@
 source_set("broadcaster") {
   sources = [
     "chrome_broadcast_observer.h",
+    "chrome_broadcast_observer_bridge.h",
+    "chrome_broadcast_observer_bridge.mm",
     "chrome_broadcaster.h",
     "chrome_broadcaster.mm",
   ]
@@ -19,6 +21,7 @@ source_set("broadcaster") {
 source_set("unit_tests") {
   testonly = true
   sources = [
+    "chrome_broadcast_observer_bridge_unittest.mm",
     "chrome_broadcaster_unittest.mm",
   ]
   deps = [

ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer_bridge.h

+// Copyright 2017 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 IOS_CHROME_BROWSER_UI_BROADCASTER_CHROME_BROADCAST_OBSERVER_BRIDGE_H_
+#define IOS_CHROME_BROWSER_UI_BROADCASTER_CHROME_BROADCAST_OBSERVER_BRIDGE_H_
+
+#import "ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer.h"
+
+// Interface for C++ objects that care about broadcasted UI state.
+class ChromeBroadcastObserverInterface {
+ public:
+  virtual ~ChromeBroadcastObserverInterface();
+
+  // Invoked by |-broadcastTabStripVisible:|.
+  virtual void OnTabStripVisbibleBroadcasted(bool visible) {}
+
+  // Invoked by |-broadcastContentScrollOffset:|.
+  virtual void OnContentScrollOffsetBroadcasted(CGFloat offset) {}
+
+  // Invoked by |-broadcastScrollViewIsScrolling:|.
+  virtual void OnScrollViewIsScrollingBroadcasted(bool scrolling) {}
+
+  // Invoked by |-broadcastScrollViewIsDragging:|.
+  virtual void OnScrollViewIsDraggingBroadcasted(bool dragging) {}
+
+  // Invoked by |-broadcastToolbarHeight:|.
+  virtual void OnToolbarHeightBroadcasted(CGFloat toolbar_height) {}
+};
+
+// Bridge object that forwards broadcasted UI state to objects that subclass
+// ChromeBroadcastObserverInterface.
+@interface ChromeBroadcastOberverBridge : NSObject<ChromeBroadcastObserver>
+
+// The observer being updated.
+@property(nonatomic, readonly, nonnull)
+    ChromeBroadcastObserverInterface* observer;
+
+// Initializer for a bridge that updates |observer|.
+- (nullable instancetype)initWithObserver:
+    (nonnull ChromeBroadcastObserverInterface*)observer
+    NS_DESIGNATED_INITIALIZER;
+- (nullable instancetype)init NS_UNAVAILABLE;
+
+@end
+
+#endif  // IOS_CHROME_BROWSER_UI_BROADCASTER_CHROME_BROADCAST_OBSERVER_BRIDGE_H_

ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer_bridge.mm

+// Copyright 2017 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.
+
+#import "ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer_bridge.h"
+
+#include "base/logging.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+ChromeBroadcastObserverInterface::~ChromeBroadcastObserverInterface() = default;
+
+@implementation ChromeBroadcastOberverBridge
+@synthesize observer = _observer;
+
+- (instancetype)initWithObserver:(ChromeBroadcastObserverInterface*)observer {
+  if (self = [super init]) {
+    _observer = observer;
+    DCHECK(_observer);
+  }
+  return self;
+}
+
+- (void)broadcastTabStripVisible:(BOOL)visible {
+  self.observer->OnTabStripVisbibleBroadcasted(visible);
+}
+
+- (void)broadcastContentScrollOffset:(CGFloat)offset {
+  self.observer->OnContentScrollOffsetBroadcasted(offset);
+}
+
+- (void)broadcastScrollViewIsScrolling:(BOOL)scrolling {
+  self.observer->OnScrollViewIsScrollingBroadcasted(scrolling);
+}
+
+- (void)broadcastScrollViewIsDragging:(BOOL)dragging {
+  self.observer->OnScrollViewIsDraggingBroadcasted(dragging);
+}
+
+- (void)broadcastToolbarHeight:(CGFloat)height {
+  self.observer->OnToolbarHeightBroadcasted(height);
+}
+
+@end

ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer_bridge_unittest.mm

+// Copyright 2017 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.
+
+#import "ios/chrome/browser/ui/broadcaster/chrome_broadcast_observer_bridge.h"
+
+#include "testing/platform_test.h"
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+// Test implementation of ChromeBroadcastObserverInterface.
+class TestChromeBroadcastObserver : public ChromeBroadcastObserverInterface {
+ public:
+  // Received broadcast values.
+  bool tab_strip_visible() const { return tab_strip_visible_; }
+  CGFloat scroll_offset() const { return scroll_offset_; }
+  bool scroll_view_scrolling() const { return scroll_view_scrolling_; }
+  bool scroll_view_dragging() const { return scroll_view_dragging_; }
+  CGFloat toolbar_height() const { return toolbar_height_; }
+
+ private:
+  // ChromeBroadcastObserverInterface:
+  void OnTabStripVisbibleBroadcasted(bool visible) override {
+    tab_strip_visible_ = visible;
+  }
+  void OnContentScrollOffsetBroadcasted(CGFloat offset) override {
+    scroll_offset_ = offset;
+  }
+  void OnScrollViewIsScrollingBroadcasted(bool scrolling) override {
+    scroll_view_scrolling_ = scrolling;
+  }
+  void OnScrollViewIsDraggingBroadcasted(bool dragging) override {
+    scroll_view_dragging_ = dragging;
+  }
+  void OnToolbarHeightBroadcasted(CGFloat toolbar_height) override {
+    toolbar_height_ = toolbar_height;
+  }
+
+  bool tab_strip_visible_ = false;
+  CGFloat scroll_offset_ = 0.0;
+  bool scroll_view_scrolling_ = false;
+  bool scroll_view_dragging_ = false;
+  CGFloat toolbar_height_ = 0.0;
+};
+
+// Test fixture for ChromeBroadcastOberverBridge.
+class ChromeBroadcastObserverBridgeTest : public PlatformTest {
+ public:
+  ChromeBroadcastObserverBridgeTest()
+      : PlatformTest(),
+        bridge_([[ChromeBroadcastOberverBridge alloc]
+            initWithObserver:&observer_]) {}
+
+  const TestChromeBroadcastObserver& observer() { return observer_; }
+  id<ChromeBroadcastObserver> bridge() { return bridge_; }
+
+ private:
+  TestChromeBroadcastObserver observer_;
+  __strong ChromeBroadcastOberverBridge* bridge_ = nil;
+};
+
+// Tests that |-broadcastContentScrollOffset:| is correctly forwarded to the
+// observer.
+TEST_F(ChromeBroadcastObserverBridgeTest, ContentOffset) {
+  ASSERT_EQ(observer().scroll_offset(), 0.0);
+  const CGFloat kOffset = 50.0;
+  [bridge() broadcastContentScrollOffset:kOffset];
+  EXPECT_EQ(observer().scroll_offset(), kOffset);
+}
+
+// Tests that |-broadcastScrollViewIsScrolling:| is correctly forwarded to the
+// observer.
+TEST_F(ChromeBroadcastObserverBridgeTest, ScrollViewIsScrolling) {
+  ASSERT_FALSE(observer().scroll_view_scrolling());
+  [bridge() broadcastScrollViewIsScrolling:YES];
+  EXPECT_TRUE(observer().scroll_view_scrolling());
+}
+
+// Tests that |-broadcastScrollViewIsDragging:| is correctly forwarded to the
+// observer.
+TEST_F(ChromeBroadcastObserverBridgeTest, ScrollViewIsDragging) {
+  ASSERT_FALSE(observer().scroll_view_dragging());
+  [bridge() broadcastScrollViewIsDragging:YES];
+  EXPECT_TRUE(observer().scroll_view_dragging());
+}
+
+// Tests that |-broadcastToolbarHeight:| is correctly forwarded to the
+// observer.
+TEST_F(ChromeBroadcastObserverBridgeTest, ToolbarHeight) {
+  ASSERT_EQ(observer().toolbar_height(), 0.0);
+  const CGFloat kHeight = 50.0;
+  [bridge() broadcastToolbarHeight:kHeight];
+  EXPECT_EQ(observer().toolbar_height(), kHeight);
+}