Support mouse lock in Flash fullscreen mode.

ppapi/examples/mouse_lock/mouse_lock.cc

 // Copyright (c) 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 <cmath>
 #include <stdarg.h>
 #include <stdio.h>
 
 #include "ppapi/c/dev/ppb_console_dev.h"
 #include "ppapi/c/ppb_input_event.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/mouse_lock.h"
+#include "ppapi/cpp/private/flash_fullscreen.h"
 #include "ppapi/cpp/rect.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 class MyInstance : public pp::Instance, public pp::MouseLock {
  public:
   explicit MyInstance(PP_Instance instance)
       : pp::Instance(instance),
         pp::MouseLock(this),
         width_(0),
         height_(0),
         mouse_locked_(false),
         pending_paint_(false),
         waiting_for_flush_completion_(false),
         callback_factory_(this),
-        console_(NULL) {
+        console_(NULL),
+        flash_fullscreen_(this) {
   }
   virtual ~MyInstance() {}
 
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     console_ = reinterpret_cast<const PPB_Console_Dev*>(
         pp::Module::Get()->GetBrowserInterface(PPB_CONSOLE_DEV_INTERFACE));
     if (!console_)
       return false;
 
     RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE |
@@ skipping 15 matching lines @@
         pp::MouseInputEvent mouse_event(event);
         mouse_movement_ = mouse_event.GetMovement();
         static unsigned int i = 0;
         Log(PP_LOGLEVEL_LOG, "[%d] movementX: %d; movementY: %d\n", i++,
             mouse_movement_.x(), mouse_movement_.y());
         Paint();
         return true;
       }
       case PP_INPUTEVENT_TYPE_KEYDOWN: {
         pp::KeyboardInputEvent key_event(event);
-        // Lock the mouse when the Enter key is pressed.
         if (key_event.GetKeyCode() == 13) {
+          // Lock the mouse when the Enter key is pressed.
           if (mouse_locked_)
             UnlockMouse();
           else
             LockMouse(callback_factory_.NewCallback(&MyInstance::DidLockMouse));
           return true;
+        } else if (key_event.GetKeyCode() == 70) {
+          // Enter Flash fullscreen mode when the 'f' key is pressed.
+          if (!flash_fullscreen_.IsFullscreen())
+            flash_fullscreen_.SetFullscreen(true);
+          return true;
         }
         return false;
       }
       default:
         return false;
     }
   }
 
   virtual void DidChangeView(const pp::Rect& position, const pp::Rect& clip) {
     if (position.size().width() == width_ &&
@@ skipping 106 matching lines @@
           bool within_bound_1 =
               ((y - anchor_1.y()) * (vertex.x() - anchor_1.x())) >
               ((vertex.y() - anchor_1.y()) * (x - anchor_1.x()));
           bool within_bound_2 =
               ((y - anchor_2.y()) * (vertex.x() - anchor_2.x())) <
               ((vertex.y() - anchor_2.y()) * (x - anchor_2.x()));
           bool within_bound_3 =
               (direction == UP && y < center_y) ||
               (direction == DOWN && y > center_y) ||
               (direction == LEFT && x < center_x) ||
-              (direction == RIGHT && x > center_y);
+              (direction == RIGHT && x > center_x);
 
           if (within_bound_1 && within_bound_2 && within_bound_3) {
             *image.GetAddr32(pp::Point(x, y)) = foreground_color;
             continue;
           }
         }
         *image.GetAddr32(pp::Point(x, y)) = kBackgroundColor;
       }
     }
 
@@ skipping 24 matching lines @@
   bool mouse_locked_;
   pp::Point mouse_movement_;
 
   bool pending_paint_;
   bool waiting_for_flush_completion_;
 
   pp::CompletionCallbackFactory<MyInstance> callback_factory_;
 
   const PPB_Console_Dev* console_;
 
+  pp::FlashFullscreen flash_fullscreen_;
+
   pp::Graphics2D device_context_;
 };
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class MyModule : public pp::Module {
  public:
   MyModule() : pp::Module() {}
   virtual ~MyModule() {}
 
   // Override CreateInstance to create your customized Instance object.
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new MyInstance(instance);
   }
 };
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new MyModule();
 }
 
 }  // namespace pp