[Android] Out with the Android GR, in with the new unified C++ GR

content/browser/android/content_view_core_impl.cc

 // Copyright 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.
 
 #include "content/browser/android/content_view_core_impl.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "content/browser/android/gesture_event_type.h"
 #include "content/browser/android/interstitial_page_delegate_android.h"
 #include "content/browser/android/load_url_params.h"
 #include "content/browser/frame_host/interstitial_page_impl.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
 #include "content/browser/media/android/browser_media_player_manager.h"
 #include "content/browser/renderer_host/compositor_impl_android.h"
+#include "content/browser/renderer_host/input/motion_event_android.h"
 #include "content/browser/renderer_host/input/web_input_event_builders_android.h"
 #include "content/browser/renderer_host/java/java_bound_object.h"
 #include "content/browser/renderer_host/java/java_bridge_dispatcher_host_manager.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_android.h"
 #include "content/browser/screen_orientation/screen_orientation_dispatcher_host.h"
 #include "content/browser/ssl/ssl_host_state.h"
 #include "content/browser/web_contents/web_contents_view_android.h"
 #include "content/common/input/web_input_event_traits.h"
@@ skipping 68 matching lines @@
     JNIEnv* env,
     const gfx::Rect& rect) {
   return ScopedJavaLocalRef<jobject>(
       Java_ContentViewCore_createRect(env,
                                       static_cast<int>(rect.x()),
                                       static_cast<int>(rect.y()),
                                       static_cast<int>(rect.right()),
                                       static_cast<int>(rect.bottom())));
 }
 
-bool PossiblyTriggeredByTouchTimeout(const WebGestureEvent& event) {
-  switch (event.type) {
-    case WebInputEvent::GestureShowPress:
-    case WebInputEvent::GestureLongPress:
-      return true;
-    // On Android, a GestureTap may be sent after a certain timeout window
-    // if there is no GestureDoubleTap follow-up.
-    case WebInputEvent::GestureTap:
-      return true;
-    // On Android, a GestureTapCancel may be triggered by the loss of window
-    //  focus (e.g., following a GestureLongPress).
-    case WebInputEvent::GestureTapCancel:
-      return true;
-    default:
-      break;
-  }
-  return false;
-}
-
-int ToContentViewGestureHandlerType(WebInputEvent::Type type) {
+int ToGestureEventType(WebInputEvent::Type type) {
   switch (type) {
     case WebInputEvent::GestureScrollBegin:
       return SCROLL_START;
     case WebInputEvent::GestureScrollEnd:
       return SCROLL_END;
     case WebInputEvent::GestureScrollUpdate:
       return SCROLL_BY;
     case WebInputEvent::GestureFlingStart:
       return FLING_START;
     case WebInputEvent::GestureFlingCancel:
@@ skipping 22 matching lines @@
       return PINCH_BY;
     case WebInputEvent::GestureTwoFingerTap:
     case WebInputEvent::GestureScrollUpdateWithoutPropagation:
     default:
       NOTREACHED() << "Invalid source gesture type: "
                    << WebInputEventTraits::GetName(type);
       return -1;
   };
 }
 
+float GetPrimaryDisplayDeviceScaleFactor() {
+  const gfx::Display& display =
+      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
+  return display.device_scale_factor();
+}
+
 }  // namespace
 
 // Enables a callback when the underlying WebContents is destroyed, to enable
 // nulling the back-pointer.
 class ContentViewCoreImpl::ContentViewUserData
     : public base::SupportsUserData::Data {
  public:
   explicit ContentViewUserData(ContentViewCoreImpl* content_view_core)
       : content_view_core_(content_view_core) {
   }
@@ skipping 39 matching lines @@
 
 ContentViewCoreImpl::ContentViewCoreImpl(JNIEnv* env,
                                          jobject obj,
                                          WebContents* web_contents,
                                          ui::ViewAndroid* view_android,
                                          ui::WindowAndroid* window_android)
     : WebContentsObserver(web_contents),
       java_ref_(env, obj),
       web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       root_layer_(cc::Layer::Create()),
+      dpi_scale_(GetPrimaryDisplayDeviceScaleFactor()),
       vsync_interval_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros)),
       expected_browser_composite_time_(base::TimeDelta::FromMicroseconds(
           kDefaultVSyncIntervalMicros * kDefaultBrowserCompositeVSyncFraction)),
       view_android_(view_android),
       window_android_(window_android),
+      gesture_provider_(this, 1.f / dpi_scale_),
       device_orientation_(0),
-      geolocation_needs_pause_(false),
-      touch_disposition_gesture_filter_(this),
-      handling_touch_event_(false) {
+      geolocation_needs_pause_(false) {
   CHECK(web_contents) <<
       "A ContentViewCoreImpl should be created with a valid WebContents.";
 
-  const gfx::Display& display =
-      gfx::Screen::GetNativeScreen()->GetPrimaryDisplay();
-  dpi_scale_ = display.device_scale_factor();
-
   // Currently, the only use case we have for overriding a user agent involves
   // spoofing a desktop Linux user agent for "Request desktop site".
   // Automatically set it for all WebContents so that it is available when a
   // NavigationEntry requires the user agent to be overridden.
   const char kLinuxInfoStr[] = "X11; Linux x86_64";
   std::string product = content::GetContentClient()->GetProduct();
   std::string spoofed_ua =
       webkit_glue::BuildUserAgentFromOSAndProduct(kLinuxInfoStr, product);
   web_contents->SetUserAgentOverride(spoofed_ua);
 
@@ skipping 104 matching lines @@
       break;
     }
   }
 }
 
 void ContentViewCoreImpl::RenderViewReady() {
   if (device_orientation_ != 0)
     SendOrientationChangeEventInternal();
 }
 
-void ContentViewCoreImpl::ForwardGestureEvent(
-    const blink::WebGestureEvent& event) {
-  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
-  if (rwhv)
-    rwhv->SendGestureEvent(event);
+void ContentViewCoreImpl::OnGestureEvent(const blink::WebGestureEvent& event) {
+  SendGestureEvent(event);
 }
 
 RenderWidgetHostViewAndroid*
     ContentViewCoreImpl::GetRenderWidgetHostViewAndroid() {
   RenderWidgetHostView* rwhv = NULL;
   if (web_contents_) {
     rwhv = web_contents_->GetRenderWidgetHostView();
     if (web_contents_->ShowingInterstitialPage()) {
       rwhv = static_cast<InterstitialPageImpl*>(
           web_contents_->GetInterstitialPage())->
@@ skipping 173 matching lines @@
     env->SetIntArrayRegion(enabled_array.obj(), i, 1, &enabled);
   }
   ScopedJavaLocalRef<jobjectArray> items_array(
       base::android::ToJavaArrayOfStrings(env, labels));
   Java_ContentViewCore_showSelectPopup(env, j_obj.obj(),
                                        items_array.obj(), enabled_array.obj(),
                                        multiple, selected_array.obj());
 }
 
 void ContentViewCoreImpl::ConfirmTouchEvent(InputEventAckState ack_result) {
-  touch_disposition_gesture_filter_.OnTouchEventAck(ack_result);
+  gesture_provider_.OnTouchEventAck(ack_result);
 }
 
 void ContentViewCoreImpl::OnGestureEventAck(const blink::WebGestureEvent& event,
                                             InputEventAckState ack_result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return;
 
   switch (event.type) {
@@ skipping 51 matching lines @@
       event.type != WebInputEvent::GestureLongPress)
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> j_obj = java_ref_.get(env);
   if (j_obj.is_null())
     return false;
 
   const blink::WebGestureEvent& gesture =
       static_cast<const blink::WebGestureEvent&>(event);
-  int gesture_type = ToContentViewGestureHandlerType(event.type);
+  int gesture_type = ToGestureEventType(event.type);
   return Java_ContentViewCore_filterTapOrPressEvent(env,
                                                     j_obj.obj(),
                                                     gesture_type,
                                                     gesture.x * GetDpiScale(),
                                                     gesture.y * GetDpiScale());
+
+  // TODO(jdduke): Also report double-tap UMA, crbug/347568.
 }
 
 bool ContentViewCoreImpl::HasFocus() {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
   return Java_ContentViewCore_hasFocus(env, obj.obj());
 }
 
@@ skipping 341 matching lines @@
 
 void ContentViewCoreImpl::SendOrientationChangeEvent(JNIEnv* env,
                                                      jobject obj,
                                                      jint orientation) {
   if (device_orientation_ != orientation) {
     device_orientation_ = orientation;
     SendOrientationChangeEventInternal();
   }
 }
 
-void ContentViewCoreImpl::OnTouchEventHandlingBegin(JNIEnv* env,
-                                                    jobject obj,
-                                                    jobject motion_event) {
-  DCHECK(!handling_touch_event_);
-  handling_touch_event_ = true;
-
-  pending_touch_event_ =
-      WebTouchEventBuilder::Build(motion_event, GetDpiScale());
-
-  pending_gesture_packet_ =
-      GestureEventPacket::FromTouch(pending_touch_event_);
-}
-
-void ContentViewCoreImpl::OnTouchEventHandlingEnd(JNIEnv* env, jobject obj) {
-  if (!handling_touch_event_)
-    return;
-
-  GestureEventPacket gesture_packet;
-  std::swap(gesture_packet, pending_gesture_packet_);
-
-  handling_touch_event_ = false;
-
+jboolean ContentViewCoreImpl::OnTouchEvent(JNIEnv* env,
+                                           jobject obj,
+                                           jobject motion_event) {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (!rwhv)
-    return;
+    return false;
 
-  // Note: Order is important here, as the touch may be ack'ed synchronously
-  TouchDispositionGestureFilter::PacketResult result =
-      touch_disposition_gesture_filter_.OnGestureEventPacket(gesture_packet);
-  if (result != TouchDispositionGestureFilter::SUCCESS) {
-    NOTREACHED() << "Invalid touch gesture sequence detected.";
-    return;
-  }
-  rwhv->SendTouchEvent(pending_touch_event_);
-}
+  MotionEventAndroid event(env, motion_event, false);
 
-float ContentViewCoreImpl::GetTouchPaddingDip() {
-  return 48.0f / GetDpiScale();
+  if (!gesture_provider_.OnTouchEvent(event))
+    return false;
+
+  rwhv->SendTouchEvent(WebTouchEventBuilder::Build(event, GetDpiScale()));
+  return true;
 }
 
 float ContentViewCoreImpl::GetDpiScale() const {
   return dpi_scale_;
 }
 
 jboolean ContentViewCoreImpl::SendMouseMoveEvent(JNIEnv* env,
                                                  jobject obj,
                                                  jlong time_ms,
                                                  jfloat x,
@@ skipping 37 matching lines @@
 }
 
 WebGestureEvent ContentViewCoreImpl::MakeGestureEvent(
     WebInputEvent::Type type, int64 time_ms, float x, float y) const {
   return WebGestureEventBuilder::Build(
       type, time_ms / 1000.0, x / GetDpiScale(), y / GetDpiScale());
 }
 
 void ContentViewCoreImpl::SendGestureEvent(
     const blink::WebGestureEvent& event) {
-  // Gestures received while |handling_touch_event_| will accumulate until
-  // touch handling finishes, at which point the gestures will be pushed to the
-  // |touch_disposition_gesture_filter_|.
-  if (handling_touch_event_) {
-    pending_gesture_packet_.Push(event);
-    return;
-  }
-
-  // TODO(jdduke): In general, timeout-based gestures *should* have the same
-  // timestamp as the initial TouchStart of the current sequence. We should
-  // verify that this is true, and use that as another timeout check.
-  if (PossiblyTriggeredByTouchTimeout(event)) {
-    TouchDispositionGestureFilter::PacketResult result =
-        touch_disposition_gesture_filter_.OnGestureEventPacket(
-            GestureEventPacket::FromTouchTimeout(event));
-    DCHECK_EQ(TouchDispositionGestureFilter::SUCCESS, result);
-    return;
-  }
-
-  // If |event| was not (directly or indirectly) touch-derived, treat it as
-  // a synthetic gesture event.
-  SendSyntheticGestureEvent(event);
-}
-
-void ContentViewCoreImpl::SendSyntheticGestureEvent(
-    const blink::WebGestureEvent& event) {
-  // Synthetic gestures (e.g., those not generated directly by touches
-  // for which we expect an ack), should be forwarded directly.
-  ForwardGestureEvent(event);
+  RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
+  if (rwhv)
+    rwhv->SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::ScrollBegin(JNIEnv* env,
                                       jobject obj,
                                       jlong time_ms,
                                       jfloat x,
                                       jfloat y,
                                       jfloat hintx,
                                       jfloat hinty) {
   WebGestureEvent event = MakeGestureEvent(
@@ skipping 17 matching lines @@
   event.data.scrollUpdate.deltaX = -dx / GetDpiScale();
   event.data.scrollUpdate.deltaY = -dy / GetDpiScale();
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::FlingStart(JNIEnv* env, jobject obj, jlong time_ms,
                                      jfloat x, jfloat y, jfloat vx, jfloat vy) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureFlingStart, time_ms, x, y);
-
   event.data.flingStart.velocityX = vx / GetDpiScale();
   event.data.flingStart.velocityY = vy / GetDpiScale();
 
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::FlingCancel(JNIEnv* env, jobject obj, jlong time_ms) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureFlingCancel, time_ms, 0, 0);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::SingleTap(JNIEnv* env, jobject obj, jlong time_ms,
-                                    jfloat x, jfloat y,
-                                    jboolean disambiguation_popup_tap) {
+                                    jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureTap, time_ms, x, y);
-
   event.data.tap.tapCount = 1;
 
-  // Disambiguation popup gestures are treated as synthetic because their
-  // generating touches were never forwarded to the renderer.
-  if (disambiguation_popup_tap) {
-    SendSyntheticGestureEvent(event);
-    return;
-  }
-
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.tap.width = touch_padding_dip;
-  event.data.tap.height = touch_padding_dip;
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::SingleTapUnconfirmed(JNIEnv* env, jobject obj,
-                                               jlong time_ms,
-                                               jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapUnconfirmed, time_ms, x, y);
-
-  event.data.tap.tapCount = 1;
-
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.tap.width = touch_padding_dip;
-  event.data.tap.height = touch_padding_dip;
-
   SendGestureEvent(event);
 }
 
-void ContentViewCoreImpl::ShowPress(JNIEnv* env, jobject obj,
-                                    jlong time_ms,
-                                    jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureShowPress, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::TapCancel(JNIEnv* env,
-                                    jobject obj,
-                                    jlong time_ms,
-                                    jfloat x,
-                                    jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapCancel, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
-void ContentViewCoreImpl::TapDown(JNIEnv* env, jobject obj,
-                                  jlong time_ms,
-                                  jfloat x, jfloat y) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureTapDown, time_ms, x, y);
-  SendGestureEvent(event);
-}
-
 void ContentViewCoreImpl::DoubleTap(JNIEnv* env, jobject obj, jlong time_ms,
                                     jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureDoubleTap, time_ms, x, y);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::LongPress(JNIEnv* env, jobject obj, jlong time_ms,
-                                    jfloat x, jfloat y,
-                                    jboolean disambiguation_popup_tap) {
+                                    jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GestureLongPress, time_ms, x, y);
 
-  // Disambiguation popup gestures are treated as synthetic because their
-  // generating touches were never forwarded to the renderer.
-  if (disambiguation_popup_tap) {
-    SendSyntheticGestureEvent(event);
-    return;
-  }
-
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.longPress.width = touch_padding_dip;
-  event.data.longPress.height = touch_padding_dip;
   SendGestureEvent(event);
 }
 
-void ContentViewCoreImpl::LongTap(JNIEnv* env, jobject obj, jlong time_ms,
-                                  jfloat x, jfloat y,
-                                  jboolean disambiguation_popup_tap) {
-  WebGestureEvent event = MakeGestureEvent(
-      WebInputEvent::GestureLongTap, time_ms, x, y);
-
-  // Disambiguation popup gestures are treated as synthetic because their
-  // generating touches were never forwarded to the renderer.
-  if (disambiguation_popup_tap) {
-    SendSyntheticGestureEvent(event);
-    return;
-  }
-
-  const float touch_padding_dip = GetTouchPaddingDip();
-  event.data.longPress.width = touch_padding_dip;
-  event.data.longPress.height = touch_padding_dip;
-  SendGestureEvent(event);
-}
-
 void ContentViewCoreImpl::PinchBegin(JNIEnv* env, jobject obj, jlong time_ms,
                                      jfloat x, jfloat y) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GesturePinchBegin, time_ms, x, y);
   SendGestureEvent(event);
 }
 
 void ContentViewCoreImpl::PinchEnd(JNIEnv* env, jobject obj, jlong time_ms) {
   WebGestureEvent event = MakeGestureEvent(
       WebInputEvent::GesturePinchEnd, time_ms, 0, 0);
@@ skipping 21 matching lines @@
 }
 
 void ContentViewCoreImpl::MoveCaret(JNIEnv* env, jobject obj,
                                     jfloat x, jfloat y) {
   if (GetRenderWidgetHostViewAndroid()) {
     GetRenderWidgetHostViewAndroid()->MoveCaret(
         gfx::Point(x / GetDpiScale(), y / GetDpiScale()));
   }
 }
 
+void ContentViewCoreImpl::ResetGestureDetectors(JNIEnv* env, jobject obj) {
+  gesture_provider_.ResetGestureDetectors();
+}
+
+void ContentViewCoreImpl::IgnoreRemainingTouchEvents(JNIEnv* env, jobject obj) {
+  gesture_provider_.CancelActiveTouchSequence();
+}
+
+void ContentViewCoreImpl::OnWindowFocusLost(JNIEnv* env, jobject obj) {
+  gesture_provider_.CancelActiveTouchSequence();
+}
+
+void ContentViewCoreImpl::SetDoubleTapSupportForPageEnabled(JNIEnv* env,
+                                                            jobject obj,
+                                                            jboolean enabled) {
+  gesture_provider_.SetDoubleTapSupportForPageEnabled(enabled);
+}
+
+void ContentViewCoreImpl::SetDoubleTapSupportEnabled(JNIEnv* env,
+                                                     jobject obj,
+                                                     jboolean enabled) {
+  gesture_provider_.SetDoubleTapSupportForPlatformEnabled(enabled);
+}
+
+void ContentViewCoreImpl::SetMultiTouchZoomSupportEnabled(JNIEnv* env,
+                                                          jobject obj,
+                                                          jboolean enabled) {
+  gesture_provider_.SetMultiTouchSupportEnabled(enabled);
+}
+
 void ContentViewCoreImpl::LoadIfNecessary(JNIEnv* env, jobject obj) {
   web_contents_->GetController().LoadIfNecessary();
 }
 
 void ContentViewCoreImpl::RequestRestoreLoad(JNIEnv* env, jobject obj) {
   web_contents_->GetController().SetNeedsReload();
 }
 
 void ContentViewCoreImpl::StopLoading(JNIEnv* env, jobject obj) {
   web_contents_->Stop();
@@ skipping 391 matching lines @@
     // If it was actually enabled globally, enable it for this RenderWidget now.
     if (accessibility_state->IsAccessibleBrowser() && host_impl)
       host_impl->AddAccessibilityMode(AccessibilityModeComplete);
   } else {
     accessibility_state->ResetAccessibilityMode();
     if (host_impl)
       host_impl->ResetAccessibilityMode();
   }
 }
 
-void ContentViewCoreImpl::SendSingleTapUma(JNIEnv* env,
-                                           jobject obj,
-                                           jint type,
-                                           jint count) {
-  UMA_HISTOGRAM_ENUMERATION("Event.SingleTapType", type, count);
-}
-
-void ContentViewCoreImpl::SendActionAfterDoubleTapUma(JNIEnv* env,
-                                                      jobject obj,
-                                                      jint type,
-                                                      jboolean has_delay,
-                                                      jint count) {
-  // This UMA stat tracks a user's action after a double tap within
-  // k seconds (where k == 5 currently). This UMA will tell us if
-  // removing the tap gesture delay will lead to significantly more
-  // accidental navigations after a double tap.
-  if (has_delay) {
-    UMA_HISTOGRAM_ENUMERATION("Event.ActionAfterDoubleTapWithDelay", type,
-                              count);
-  } else {
-    UMA_HISTOGRAM_ENUMERATION("Event.ActionAfterDoubleTapNoDelay", type,
-                              count);
-  }
-}
-
 void ContentViewCoreImpl::SendOrientationChangeEventInternal() {
   RenderWidgetHostViewAndroid* rwhv = GetRenderWidgetHostViewAndroid();
   if (rwhv)
     rwhv->UpdateScreenInfo(rwhv->GetNativeView());
 
   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(
       web_contents_->GetRenderViewHost());
   rvhi->SendOrientationChangeEvent(device_orientation_);
 
   // TODO(mlamouri): temporary plumbing for Screen Orientation, this will change
@@ skipping 76 matching lines @@
       reinterpret_cast<ui::ViewAndroid*>(view_android),
       reinterpret_cast<ui::WindowAndroid*>(window_android));
   return reinterpret_cast<intptr_t>(view);
 }
 
 bool RegisterContentViewCore(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace content