Mandoline: Add WebGL support

components/html_viewer/blink_platform_impl.cc

 // 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.
 
 #include "components/html_viewer/blink_platform_impl.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/rand_util.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "components/html_viewer/blink_resource_constants.h"
 #include "components/html_viewer/web_clipboard_impl.h"
 #include "components/html_viewer/web_cookie_jar_impl.h"
+#include "components/html_viewer/web_graphics_context_3d_command_buffer_impl.h"
 #include "components/html_viewer/web_socket_handle_impl.h"
 #include "components/html_viewer/web_url_loader_impl.h"
 #include "components/message_port/web_message_port_channel_impl.h"
 #include "components/mime_util/mime_util.h"
 #include "components/scheduler/child/webthread_impl_for_worker_scheduler.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "components/scheduler/renderer/webthread_impl_for_renderer_scheduler.h"
 #include "mojo/application/public/cpp/application_impl.h"
 #include "mojo/application/public/cpp/connect.h"
 #include "mojo/common/user_agent.h"
 #include "net/base/data_url.h"
 #include "net/base/ip_address_number.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "third_party/WebKit/public/platform/WebWaitableEvent.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/gestures/blink/web_gesture_curve_impl.h"
+#include "url/gurl.h"
 
 namespace html_viewer {
 namespace {
 
 // Allows overriding user agent scring.
 const char kUserAgentSwitch[] = "user-agent";
+const char kEnableWebGLSwitch[] = "enable-webgl";
 
 class WebWaitableEventImpl : public blink::WebWaitableEvent {
  public:
   WebWaitableEventImpl(ResetPolicy policy, InitialState state) {
     bool manual_reset = policy == ResetPolicy::Manual;
     bool initially_signaled = state == InitialState::Signaled;
     impl_.reset(new base::WaitableEvent(manual_reset, initially_signaled));
   }
   virtual ~WebWaitableEventImpl() {}
 
   virtual void reset() { impl_->Reset(); }
   virtual void wait() { impl_->Wait(); }
   virtual void signal() { impl_->Signal(); }
 
   base::WaitableEvent* impl() {
     return impl_.get();
   }
 
  private:
   scoped_ptr<base::WaitableEvent> impl_;
   DISALLOW_COPY_AND_ASSIGN(WebWaitableEventImpl);
 };
 
 }  // namespace
 
 BlinkPlatformImpl::BlinkPlatformImpl(
     mojo::ApplicationImpl* app,
     scheduler::RendererScheduler* renderer_scheduler)
-    : main_thread_task_runner_(renderer_scheduler->DefaultTaskRunner()),
+    : app_(app),
+      main_thread_task_runner_(renderer_scheduler->DefaultTaskRunner()),
       main_thread_(new scheduler::WebThreadImplForRendererScheduler(
           renderer_scheduler)) {
   if (app) {
     mojo::URLRequestPtr request(mojo::URLRequest::New());
     request->url = mojo::String::From("mojo:network_service");
     scoped_ptr<mojo::ApplicationConnection> connection =
         app->ConnectToApplication(request.Pass());
     connection->ConnectToService(&web_socket_factory_);
     connection->ConnectToService(&url_loader_factory_);
 
@@ skipping 73 matching lines @@
 blink::WebScrollbarBehavior* BlinkPlatformImpl::scrollbarBehavior() {
   return &scrollbar_behavior_;
 }
 
 const unsigned char* BlinkPlatformImpl::getTraceCategoryEnabledFlag(
     const char* category_name) {
   static const unsigned char buf[] = "*";
   return buf;
 }
 
+blink::WebGraphicsContext3D*
+BlinkPlatformImpl::createOffscreenGraphicsContext3D(
+    const blink::WebGraphicsContext3D::Attributes& attributes,
+    blink::WebGraphicsContext3D* shareContext) {
+  return createOffscreenGraphicsContext3D(attributes, shareContext, nullptr);
+}
+
+blink::WebGraphicsContext3D*
+BlinkPlatformImpl::createOffscreenGraphicsContext3D(
+    const blink::WebGraphicsContext3D::Attributes& attributes,
+    blink::WebGraphicsContext3D* shareContext,
+    blink::WebGLInfo* glInfo) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(kEnableWebGLSwitch)) {

[Fady Samuel, 2015/09/14 19:21:43]

Why make this a switch?

[Peng, 2015/09/14 19:28:46]

I tested it with some simple webgl pages, it works fine. But it could have
issues with some complex webgl pages. So having a switch is safer. WDYT?

+    return WebGraphicsContext3DCommandBufferImpl::CreateOffscreenContext(
+        app_, GURL(attributes.topDocumentURL), attributes, shareContext,
+        glInfo);
+  }
+  return nullptr;
+}
+
+blink::WebGraphicsContext3D*
+BlinkPlatformImpl::createOffscreenGraphicsContext3D(
+    const blink::WebGraphicsContext3D::Attributes& attributes) {
+  return createOffscreenGraphicsContext3D(attributes, nullptr, nullptr);
+}
+
+blink::WebGraphicsContext3DProvider*
+BlinkPlatformImpl::createSharedOffscreenGraphicsContext3DProvider() {
+  return nullptr;
+}
+
 blink::WebData BlinkPlatformImpl::loadResource(const char* resource) {
   for (size_t i = 0; i < arraysize(kDataResources); ++i) {
     if (!strcmp(resource, kDataResources[i].name)) {
       base::StringPiece data =
           ResourceBundle::GetSharedInstance().GetRawDataResourceForScale(
               kDataResources[i].id, ui::SCALE_FACTOR_100P);
       return blink::WebData(data.data(), data.size());
     }
   }
   NOTREACHED() << "Requested resource is unavailable: " << resource;
@@ skipping 105 matching lines @@
 BlinkPlatformImpl::notificationManager() {
   return &web_notification_manager_;
 }
 
 void BlinkPlatformImpl::UpdateWebThreadTLS(blink::WebThread* thread) {
   DCHECK(!current_thread_slot_.Get());
   current_thread_slot_.Set(thread);
 }
 
 }  // namespace html_viewer