content/test/layouttest_support.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/public/test/layouttest_support.h"
   6
   7 #include "base/callback.h"
   8 #include "base/lazy_instance.h"
   9 #include "content/browser/renderer_host/render_widget_host_impl.h"
  10 #include "content/common/gpu/image_transport_surface.h"
  11 #include "content/public/common/page_state.h"
  12 #include "content/renderer/history_entry.h"
  13 #include "content/renderer/history_serialization.h"
  14 #include "content/renderer/render_frame_impl.h"
  15 #include "content/renderer/render_thread_impl.h"
  16 #include "content/renderer/render_view_impl.h"
  17 #include "content/renderer/renderer_webkitplatformsupport_impl.h"
  18 #include "content/shell/renderer/test_runner/TestCommon.h"
  19 #include "content/shell/renderer/test_runner/WebFrameTestProxy.h"
  20 #include "content/shell/renderer/test_runner/WebTestProxy.h"
  21 #include "content/test/test_media_stream_client.h"
  22 #include "third_party/WebKit/public/platform/WebDeviceMotionData.h"
  23 #include "third_party/WebKit/public/platform/WebDeviceOrientationData.h"
  24 #include "third_party/WebKit/public/platform/WebGamepads.h"
  25 #include "third_party/WebKit/public/web/WebHistoryItem.h"
  26
  27 #if defined(OS_MACOSX)
  28 #include "content/browser/renderer_host/popup_menu_helper_mac.h"
  29 #endif
  30
  31 using blink::WebDeviceMotionData;
  32 using blink::WebDeviceOrientationData;
  33 using blink::WebGamepad;
  34 using blink::WebGamepads;
  35 using blink::WebRect;
  36 using blink::WebSize;
  37
  38 namespace content {
  39
  40 namespace {
  41
  42 base::LazyInstance<base::Callback<void(RenderView*, WebTestProxyBase*)> >::Leaky
  43     g_callback = LAZY_INSTANCE_INITIALIZER;
  44
  45 RenderViewImpl* CreateWebTestProxy(RenderViewImplParams* params) {
  46   typedef WebTestProxy<RenderViewImpl, RenderViewImplParams*> ProxyType;
  47   ProxyType* render_view_proxy = new ProxyType(params);
  48   if (g_callback == 0)
  49     return render_view_proxy;
  50   g_callback.Get().Run(render_view_proxy, render_view_proxy);
  51   return render_view_proxy;
  52 }
  53
  54 WebTestProxyBase* GetWebTestProxyBase(RenderViewImpl* render_view) {
  55   typedef WebTestProxy<RenderViewImpl, RenderViewImplParams*> ViewProxy;
  56
  57   ViewProxy* render_view_proxy = static_cast<ViewProxy*>(render_view);
  58   return static_cast<WebTestProxyBase*>(render_view_proxy);
  59 }
  60
  61 RenderFrameImpl* CreateWebFrameTestProxy(
  62     RenderViewImpl* render_view,
  63     int32 routing_id) {
  64   typedef WebFrameTestProxy<RenderFrameImpl, RenderViewImpl*, int32> FrameProxy;
  65
  66   FrameProxy* render_frame_proxy = new FrameProxy(render_view, routing_id);
  67   render_frame_proxy->setBaseProxy(GetWebTestProxyBase(render_view));
  68
  69   UseMockMediaStreams(render_frame_proxy);
  70
  71   return render_frame_proxy;
  72 }
  73
  74 }  // namespace
  75
  76
  77 void EnableWebTestProxyCreation(
  78     const base::Callback<void(RenderView*, WebTestProxyBase*)>& callback) {
  79   g_callback.Get() = callback;
  80   RenderViewImpl::InstallCreateHook(CreateWebTestProxy);
  81   RenderFrameImpl::InstallCreateHook(CreateWebFrameTestProxy);
  82 }
  83
  84 void SetMockGamepads(const WebGamepads& pads) {
  85   RendererWebKitPlatformSupportImpl::SetMockGamepadsForTesting(pads);
  86 }
  87
  88 void MockGamepadConnected(int index, const WebGamepad& pad) {
  89   RendererWebKitPlatformSupportImpl::MockGamepadConnected(index, pad);
  90 }
  91
  92 void MockGamepadDisconnected(int index, const WebGamepad& pad) {
  93   RendererWebKitPlatformSupportImpl::MockGamepadDisconnected(index, pad);
  94 }
  95
  96 void SetMockDeviceMotionData(const WebDeviceMotionData& data) {
  97   RendererWebKitPlatformSupportImpl::SetMockDeviceMotionDataForTesting(data);
  98 }
  99
 100 void SetMockDeviceOrientationData(const WebDeviceOrientationData& data) {
 101   RendererWebKitPlatformSupportImpl::
 102       SetMockDeviceOrientationDataForTesting(data);
 103 }
 104
 105 void SetMockScreenOrientation(
 106     const blink::WebScreenOrientationType& orientation) {
 107   RendererWebKitPlatformSupportImpl::
 108       SetMockScreenOrientationForTesting(orientation);
 109 }
 110
 111 void EnableRendererLayoutTestMode() {
 112   RenderThreadImpl::current()->set_layout_test_mode(true);
 113 }
 114
 115 void EnableBrowserLayoutTestMode() {
 116 #if defined(OS_MACOSX)
 117   ImageTransportSurface::SetAllowOSMesaForTesting(true);
 118   PopupMenuHelper::DontShowPopupMenuForTesting();
 119 #endif
 120   RenderWidgetHostImpl::DisableResizeAckCheckForTesting();
 121 }
 122
 123 int GetLocalSessionHistoryLength(RenderView* render_view) {
 124   return static_cast<RenderViewImpl*>(render_view)->
 125       GetLocalSessionHistoryLengthForTesting();
 126 }
 127
 128 void SyncNavigationState(RenderView* render_view) {
 129   static_cast<RenderViewImpl*>(render_view)->SyncNavigationState();
 130 }
 131
 132 void SetFocusAndActivate(RenderView* render_view, bool enable) {
 133   static_cast<RenderViewImpl*>(render_view)->
 134       SetFocusAndActivateForTesting(enable);
 135 }
 136
 137 void ForceResizeRenderView(RenderView* render_view,
 138                            const WebSize& new_size) {
 139   RenderViewImpl* render_view_impl = static_cast<RenderViewImpl*>(render_view);
 140   render_view_impl->ForceResizeForTesting(new_size);
 141   GetWebTestProxyBase(render_view_impl)->didForceResize();
 142 }
 143
 144 void SetDeviceScaleFactor(RenderView* render_view, float factor) {
 145   static_cast<RenderViewImpl*>(render_view)->
 146       SetDeviceScaleFactorForTesting(factor);
 147 }
 148
 149 void UseSynchronousResizeMode(RenderView* render_view, bool enable) {
 150   static_cast<RenderViewImpl*>(render_view)->
 151       UseSynchronousResizeModeForTesting(enable);
 152 }
 153
 154 void EnableAutoResizeMode(RenderView* render_view,
 155                           const WebSize& min_size,
 156                           const WebSize& max_size) {
 157   static_cast<RenderViewImpl*>(render_view)->
 158       EnableAutoResizeForTesting(min_size, max_size);
 159 }
 160
 161 void DisableAutoResizeMode(RenderView* render_view, const WebSize& new_size) {
 162   static_cast<RenderViewImpl*>(render_view)->
 163       DisableAutoResizeForTesting(new_size);
 164 }
 165
 166 void UseMockMediaStreams(RenderFrame* render_frame) {
 167   RenderFrameImpl* render_frame_impl = static_cast<RenderFrameImpl*>(
 168       render_frame);
 169   render_frame_impl->SetMediaStreamClientForTesting(
 170       new TestMediaStreamClient(render_frame_impl));
 171 }
 172
 173 struct ToLower {
 174   base::char16 operator()(base::char16 c) { return tolower(c); }
 175 };
 176
 177 // Returns True if node1 < node2.
 178 bool HistoryEntryCompareLess(HistoryEntry::HistoryNode* node1,
 179                              HistoryEntry::HistoryNode* node2) {
 180   base::string16 target1 = node1->item().target();
 181   base::string16 target2 = node2->item().target();
 182   std::transform(target1.begin(), target1.end(), target1.begin(), ToLower());
 183   std::transform(target2.begin(), target2.end(), target2.begin(), ToLower());
 184   return target1 < target2;
 185 }
 186
 187 std::string DumpHistoryItem(HistoryEntry::HistoryNode* node,
 188                             int indent,
 189                             bool is_current_index) {
 190   std::string result;
 191
 192   const blink::WebHistoryItem& item = node->item();
 193   if (is_current_index) {
 194     result.append("curr->");
 195     result.append(indent - 6, ' '); // 6 == "curr->".length()
 196   } else {
 197     result.append(indent, ' ');
 198   }
 199
 200   std::string url = normalizeLayoutTestURL(item.urlString().utf8());
 201   result.append(url);
 202   if (!item.target().isEmpty()) {
 203     result.append(" (in frame \"");
 204     result.append(item.target().utf8());
 205     result.append("\")");
 206   }
 207   result.append("\n");
 208
 209   std::vector<HistoryEntry::HistoryNode*> children = node->children();
 210   if (!children.empty()) {
 211     std::sort(children.begin(), children.end(), HistoryEntryCompareLess);
 212     for (size_t i = 0; i < children.size(); ++i)
 213       result += DumpHistoryItem(children[i], indent + 4, false);
 214   }
 215
 216   return result;
 217 }
 218
 219 std::string DumpBackForwardList(std::vector<PageState>& page_state,
 220                                 size_t current_index) {
 221   std::string result;
 222   result.append("\n============== Back Forward List ==============\n");
 223   for (size_t index = 0; index < page_state.size(); ++index) {
 224     scoped_ptr<HistoryEntry> entry(
 225         PageStateToHistoryEntry(page_state[index]));
 226     result.append(
 227         DumpHistoryItem(entry->root_history_node(),
 228                         8,
 229                         index == current_index));
 230   }
 231   result.append("===============================================\n");
 232   return result;
 233 }
 234
 235 }  // namespace content