Implement off-screen rendering support using delegated rendering (issue #1257).

This implementation supports both GPU compositing and software compositing (used when GPU is not supported or when passing `--disable-gpu --disable-gpu-compositing` command-line flags). GPU-accelerated features (WebGL and 3D CSS) that did not work with the previous off-screen rendering implementation do work with this implementation when GPU support is available.

Rendering now operates on a per-frame basis. The frame rate is configurable via CefBrowserSettings.windowless_frame_rate up to a maximum of 60fps (potentially limited by how fast the system can generate new frames). CEF generates a bitmap from the compositor backing and passes it to CefRenderHandler::OnPaint.

The previous CefRenderHandler/CefBrowserHost API for off-screen rendering has been restored mostly as-is with some minor changes:

- CefBrowserHost::Invalidate no longer accepts a CefRect region argument. Instead of invalidating a specific region it now triggers generation of a new frame.
- The |dirtyRects| argument to CefRenderHandler::OnPaint will now always be a single CefRect representing the whole view (frame) size. Previously, invalidated regions were listed separately.
- Linux: CefBrowserHost::SendKeyEvent now expects X11 event information instead of GTK event information. See cefclient for an example of converting GTK events to the necessary format.
- Sizes passed to the CefRenderHandler OnPaint and OnPopupSize methods are now already DPI scaled. Previously, the client had to perform DPI scaling.
- Includes drag&drop implementation from issue #1032.
- Includes unit test fixes from issue #1245.

git-svn-id: https://chromiumembedded.googlecode.com/svn/trunk@1751 5089003a-bbd8-11dd-ad1f-f1f9622dbc98

libcef/browser/menu_creator_runner_linux.cc

@@ -24,14 +24,34 @@ CefMenuCreatorRunnerLinux::~CefMenuCreatorRunnerLinux() {
 bool CefMenuCreatorRunnerLinux::RunContextMenu(CefMenuCreator* manager) {
   menu_.reset(new views::MenuRunner(manager->model()));
 
-  // We can't use aura::Window::GetBoundsInScreen on Linux because it will
-  // return bounds from DesktopWindowTreeHostX11 which in our case is relative
-  // to the parent window instead of the root window (screen).
-  const gfx::Rect& bounds_in_screen =
-      manager->browser()->window_x11()->GetBoundsInScreen();
-  gfx::Point screen_point =
-      gfx::Point(bounds_in_screen.x() + manager->params().x,
-                 bounds_in_screen.y() + manager->params().y);
+  gfx::Point screen_point;
+
+  if (manager->browser()->IsWindowless()) {
+    CefRefPtr<CefClient> client = manager->browser()->GetClient();
+    if (!client.get())
+      return false;
+
+    CefRefPtr<CefRenderHandler> handler = client->GetRenderHandler();
+    if (!handler.get())
+      return false;
+
+    int screenX = 0, screenY = 0;
+    if (!handler->GetScreenPoint(manager->browser(),
+                                 manager->params().x, manager->params().y,
+                                 screenX, screenY)) {
+      return false;
+    }
+
+    screen_point = gfx::Point(screenX, screenY);
+  } else {
+    // We can't use aura::Window::GetBoundsInScreen on Linux because it will
+    // return bounds from DesktopWindowTreeHostX11 which in our case is relative
+    // to the parent window instead of the root window (screen).
+    const gfx::Rect& bounds_in_screen =
+        manager->browser()->window_x11()->GetBoundsInScreen();
+    screen_point = gfx::Point(bounds_in_screen.x() + manager->params().x,
+                              bounds_in_screen.y() + manager->params().y);
+  }
 
   views::MenuRunner::RunResult result =
       menu_->RunMenuAt(manager->browser()->window_widget(),
@@ -44,6 +64,11 @@ bool CefMenuCreatorRunnerLinux::RunContextMenu(CefMenuCreator* manager) {
   return true;
 }
 
+void CefMenuCreatorRunnerLinux::CancelContextMenu() {
+  if (menu_)
+    menu_->Cancel();
+}
+
 bool CefMenuCreatorRunnerLinux::FormatLabel(base::string16& label) {
   // Remove the accelerator indicator (&) from label strings.
   const char16 replace[] = {L'&', 0};