kc3-lang/angle/util/OSWindow.cpp

• Show log

  Commit

• Hash : 3d8dff0a
  Author :
  Date : 2025-08-26T20:23:21
  

  Suppress unsafe buffers on a file-by-file basis in util/
  
  Bug: b/436880895
  Change-Id: I299247e38853bb16afd466e3f6521342c0a2b0f8
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6891980
  Auto-Submit: Tom Sepez <tsepez@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• util/OSWindow.cpp

• //
  // Copyright 2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #ifdef UNSAFE_BUFFERS_BUILD
  #    pragma allow_unsafe_libc_calls
  #endif
  
  #include "OSWindow.h"
  
  #include <cstring>
  #include <fstream>
  #include <iostream>
  #include <sstream>
  
  #include "common/debug.h"
  #include "common/system_utils.h"
  
  #if defined(ANGLE_PLATFORM_ANDROID)
  #    include "util/android/AndroidWindow.h"
  #endif  // defined(ANGLE_PLATFORM_ANDROID)
  
  #ifndef DEBUG_EVENTS
  #    define DEBUG_EVENTS 0
  #endif
  
  #if DEBUG_EVENTS
  static const char *MouseButtonName(angle::MouseButtonType button)
  {
      switch (button)
      {
          case angle::MouseButtonType::UNKNOWN:
              return "Unknown";
          case angle::MouseButtonType::LEFT:
              return "Left";
          case angle::MouseButtonType::RIGHT:
              return "Right";
          case angle::MouseButtonType::MIDDLE:
              return "Middle";
          case angle::MouseButtonType::BUTTON4:
              return "Button4";
          case angle::MouseButtonType::BUTTON5:
              return "Button5";
          default:
              UNREACHABLE();
              return nullptr;
      }
  }
  
  static const char *KeyName(angle::KeyType key)
  {
      switch (key)
      {
          case angle::KeyType::UNKNOWN:
              return "Unknown";
          case angle::KeyType::A:
              return "A";
          case angle::KeyType::B:
              return "B";
          case angle::KeyType::C:
              return "C";
          case angle::KeyType::D:
              return "D";
          case angle::KeyType::E:
              return "E";
          case angle::KeyType::F:
              return "F";
          case angle::KeyType::G:
              return "G";
          case angle::KeyType::H:
              return "H";
          case angle::KeyType::I:
              return "I";
          case angle::KeyType::J:
              return "J";
          case angle::KeyType::K:
              return "K";
          case angle::KeyType::L:
              return "L";
          case angle::KeyType::M:
              return "M";
          case angle::KeyType::N:
              return "N";
          case angle::KeyType::O:
              return "O";
          case angle::KeyType::P:
              return "P";
          case angle::KeyType::Q:
              return "Q";
          case angle::KeyType::R:
              return "R";
          case angle::KeyType::S:
              return "S";
          case angle::KeyType::T:
              return "T";
          case angle::KeyType::U:
              return "U";
          case angle::KeyType::V:
              return "V";
          case angle::KeyType::W:
              return "W";
          case angle::KeyType::X:
              return "X";
          case angle::KeyType::Y:
              return "Y";
          case angle::KeyType::Z:
              return "Z";
          case angle::KeyType::NUM0:
              return "Num0";
          case angle::KeyType::NUM1:
              return "Num1";
          case angle::KeyType::NUM2:
              return "Num2";
          case angle::KeyType::NUM3:
              return "Num3";
          case angle::KeyType::NUM4:
              return "Num4";
          case angle::KeyType::NUM5:
              return "Num5";
          case angle::KeyType::NUM6:
              return "Num6";
          case angle::KeyType::NUM7:
              return "Num7";
          case angle::KeyType::NUM8:
              return "Num8";
          case angle::KeyType::NUM9:
              return "Num9";
          case angle::KeyType::ESCAPE:
              return "Escape";
          case angle::KeyType::LCONTROL:
              return "Left Control";
          case angle::KeyType::LSHIFT:
              return "Left Shift";
          case angle::KeyType::LALT:
              return "Left Alt";
          case angle::KeyType::LSYSTEM:
              return "Left System";
          case angle::KeyType::RCONTROL:
              return "Right Control";
          case angle::KeyType::RSHIFT:
              return "Right Shift";
          case angle::KeyType::RALT:
              return "Right Alt";
          case angle::KeyType::RSYSTEM:
              return "Right System";
          case angle::KeyType::MENU:
              return "Menu";
          case angle::KeyType::LBRACKET:
              return "Left Bracket";
          case angle::KeyType::RBRACKET:
              return "Right Bracket";
          case angle::KeyType::SEMICOLON:
              return "Semicolon";
          case angle::KeyType::COMMA:
              return "Comma";
          case angle::KeyType::PERIOD:
              return "Period";
          case angle::KeyType::QUOTE:
              return "Quote";
          case angle::KeyType::SLASH:
              return "Slash";
          case angle::KeyType::BACKSLASH:
              return "Backslash";
          case angle::KeyType::TILDE:
              return "Tilde";
          case angle::KeyType::EQUAL:
              return "Equal";
          case angle::KeyType::DASH:
              return "Dash";
          case angle::KeyType::SPACE:
              return "Space";
          case angle::KeyType::RETURN:
              return "Return";
          case angle::KeyType::BACK:
              return "Back";
          case angle::KeyType::TAB:
              return "Tab";
          case angle::KeyType::PAGEUP:
              return "Page Up";
          case angle::KeyType::PAGEDOWN:
              return "Page Down";
          case angle::KeyType::END:
              return "End";
          case angle::KeyType::HOME:
              return "Home";
          case angle::KeyType::INSERT:
              return "Insert";
          case angle::KeyType::DEL:
              return "Delete";
          case angle::KeyType::ADD:
              return "Add";
          case angle::KeyType::SUBTRACT:
              return "Substract";
          case angle::KeyType::MULTIPLY:
              return "Multiply";
          case angle::KeyType::DIVIDE:
              return "Divide";
          case angle::KeyType::LEFT:
              return "Left";
          case angle::KeyType::RIGHT:
              return "Right";
          case angle::KeyType::UP:
              return "Up";
          case angle::KeyType::DOWN:
              return "Down";
          case angle::KeyType::NUMPAD0:
              return "Numpad 0";
          case angle::KeyType::NUMPAD1:
              return "Numpad 1";
          case angle::KeyType::NUMPAD2:
              return "Numpad 2";
          case angle::KeyType::NUMPAD3:
              return "Numpad 3";
          case angle::KeyType::NUMPAD4:
              return "Numpad 4";
          case angle::KeyType::NUMPAD5:
              return "Numpad 5";
          case angle::KeyType::NUMPAD6:
              return "Numpad 6";
          case angle::KeyType::NUMPAD7:
              return "Numpad 7";
          case angle::KeyType::NUMPAD8:
              return "Numpad 8";
          case angle::KeyType::NUMPAD9:
              return "Numpad 9";
          case angle::KeyType::F1:
              return "F1";
          case angle::KeyType::F2:
              return "F2";
          case angle::KeyType::F3:
              return "F3";
          case angle::KeyType::F4:
              return "F4";
          case angle::KeyType::F5:
              return "F5";
          case angle::KeyType::F6:
              return "F6";
          case angle::KeyType::F7:
              return "F7";
          case angle::KeyType::F8:
              return "F8";
          case angle::KeyType::F9:
              return "F9";
          case angle::KeyType::F10:
              return "F10";
          case angle::KeyType::F11:
              return "F11";
          case angle::KeyType::F12:
              return "F12";
          case angle::KeyType::F13:
              return "F13";
          case angle::KeyType::F14:
              return "F14";
          case angle::KeyType::F15:
              return "F15";
          case angle::KeyType::PAUSE:
              return "Pause";
          default:
              return "Unknown Key";
      }
  }
  
  static std::string KeyState(const Event::KeyEvent &event)
  {
      if (event.Shift || event.Control || event.Alt || event.System)
      {
          std::ostringstream buffer;
          buffer << " [";
  
          if (event.Shift)
          {
              buffer << "Shift";
          }
          if (event.Control)
          {
              buffer << "Control";
          }
          if (event.Alt)
          {
              buffer << "Alt";
          }
          if (event.System)
          {
              buffer << "System";
          }
  
          buffer << "]";
          return buffer.str();
      }
      return "";
  }
  
  static void PrintEvent(const Event &event)
  {
      switch (event.Type)
      {
          case Event::EVENT_CLOSED:
              std::cout << "Event: Window Closed" << std::endl;
              break;
          case Event::EVENT_MOVED:
              std::cout << "Event: Window Moved (" << event.Move.X << ", " << event.Move.Y << ")"
                        << std::endl;
              break;
          case Event::EVENT_RESIZED:
              std::cout << "Event: Window Resized (" << event.Size.Width << ", " << event.Size.Height
                        << ")" << std::endl;
              break;
          case Event::EVENT_LOST_FOCUS:
              std::cout << "Event: Window Lost Focus" << std::endl;
              break;
          case Event::EVENT_GAINED_FOCUS:
              std::cout << "Event: Window Gained Focus" << std::endl;
              break;
          case Event::EVENT_TEXT_ENTERED:
              // TODO(cwallez) show the character
              std::cout << "Event: Text Entered" << std::endl;
              break;
          case Event::EVENT_KEY_PRESSED:
              std::cout << "Event: Key Pressed (" << KeyName(event.Key.Code) << KeyState(event.Key)
                        << ")" << std::endl;
              break;
          case Event::EVENT_KEY_RELEASED:
              std::cout << "Event: Key Released (" << KeyName(event.Key.Code) << KeyState(event.Key)
                        << ")" << std::endl;
              break;
          case Event::EVENT_MOUSE_WHEEL_MOVED:
              std::cout << "Event: Mouse Wheel (" << event.MouseWheel.Delta << ")" << std::endl;
              break;
          case Event::EVENT_MOUSE_BUTTON_PRESSED:
              std::cout << "Event: Mouse Button Pressed " << MouseButtonName(event.MouseButton.Button)
                        << " at (" << event.MouseButton.X << ", " << event.MouseButton.Y << ")"
                        << std::endl;
              break;
          case Event::EVENT_MOUSE_BUTTON_RELEASED:
              std::cout << "Event: Mouse Button Released "
                        << MouseButtonName(event.MouseButton.Button) << " at (" << event.MouseButton.X
                        << ", " << event.MouseButton.Y << ")" << std::endl;
              break;
          case Event::EVENT_MOUSE_MOVED:
              std::cout << "Event: Mouse Moved (" << event.MouseMove.X << ", " << event.MouseMove.Y
                        << ")" << std::endl;
              break;
          case Event::EVENT_MOUSE_ENTERED:
              std::cout << "Event: Mouse Entered Window" << std::endl;
              break;
          case Event::EVENT_MOUSE_LEFT:
              std::cout << "Event: Mouse Left Window" << std::endl;
              break;
          case Event::EVENT_TEST:
              std::cout << "Event: Test" << std::endl;
              break;
          default:
              UNREACHABLE();
              break;
      }
  }
  #endif
  
  OSWindow::OSWindow() : mX(0), mY(0), mWidth(0), mHeight(0), mValid(false), mIgnoreSizeEvents(false)
  {}
  
  OSWindow::~OSWindow() {}
  
  bool OSWindow::initialize(const std::string &name, int width, int height)
  {
      mValid = initializeImpl(name, width, height);
      return mValid;
  }
  
  int OSWindow::getX() const
  {
      return mX;
  }
  
  int OSWindow::getY() const
  {
      return mY;
  }
  
  int OSWindow::getWidth() const
  {
      return mWidth;
  }
  
  int OSWindow::getHeight() const
  {
      return mHeight;
  }
  
  bool OSWindow::takeScreenshot(uint8_t *pixelData)
  {
      return false;
  }
  
  void *OSWindow::getPlatformExtension()
  {
      return reinterpret_cast<void *>(getNativeWindow());
  }
  
  bool OSWindow::popEvent(Event *event)
  {
      if (mEvents.size() > 0 && event)
      {
          *event = mEvents.front();
          mEvents.pop_front();
          return true;
      }
      else
      {
          return false;
      }
  }
  
  void OSWindow::pushEvent(Event event)
  {
      switch (event.Type)
      {
          case Event::EVENT_MOVED:
              mX = event.Move.X;
              mY = event.Move.Y;
              break;
          case Event::EVENT_RESIZED:
              mWidth  = event.Size.Width;
              mHeight = event.Size.Height;
              break;
          default:
              break;
      }
  
      mEvents.push_back(event);
  
  #if DEBUG_EVENTS
      PrintEvent(event);
  #endif
  }
  
  bool OSWindow::didTestEventFire()
  {
      Event topEvent;
      while (popEvent(&topEvent))
      {
          if (topEvent.Type == Event::EVENT_TEST)
          {
              return true;
          }
      }
  
      return false;
  }
  
  // static
  void OSWindow::Delete(OSWindow **window)
  {
      delete *window;
      *window = nullptr;
  }
  
  namespace angle
  {
  bool FindTestDataPath(const char *searchPath, char *dataPathOut, size_t maxDataPathOutLen)
  {
  #if defined(ANGLE_PLATFORM_ANDROID)
      const std::string searchPaths[] = {
          AndroidWindow::GetExternalStorageDirectory(),
          AndroidWindow::GetExternalStorageDirectory() + "/third_party/angle",
          AndroidWindow::GetApplicationDirectory() + "/chromium_tests_root"};
  #elif ANGLE_PLATFORM_IOS_FAMILY
      const std::string searchPaths[] = {GetExecutableDirectory(),
                                         GetExecutableDirectory() + "/third_party/angle"};
  #else
      const std::string searchPaths[] = {
          GetExecutableDirectory(), GetExecutableDirectory() + "/../..", ".",
          GetExecutableDirectory() + "/../../third_party/angle", "third_party/angle"};
  #endif  // defined(ANGLE_PLATFORM_ANDROID)
  
      for (const std::string &path : searchPaths)
      {
          std::stringstream pathStream;
          pathStream << path << "/" << searchPath;
          std::string candidatePath = pathStream.str();
  
          if (candidatePath.size() + 1 >= maxDataPathOutLen)
          {
              ERR() << "FindTestDataPath: Path too long.";
              return false;
          }
  
          if (angle::IsDirectory(candidatePath.c_str()))
          {
              memcpy(dataPathOut, candidatePath.c_str(), candidatePath.size() + 1);
              return true;
          }
  
          std::ifstream inFile(candidatePath.c_str());
          if (!inFile.fail())
          {
              memcpy(dataPathOut, candidatePath.c_str(), candidatePath.size() + 1);
              return true;
          }
      }
  
      return false;
  }
  }  // namespace angle
  

Download