ppapi/proxy/serialized_flash_menu.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 "ppapi/proxy/serialized_flash_menu.h"
   6
   7 #include "ipc/ipc_message.h"
   8 #include "ppapi/c/private/ppb_flash_menu.h"
   9 #include "ppapi/proxy/ppapi_param_traits.h"
  10
  11 namespace ppapi {
  12 namespace proxy {
  13
  14 namespace {
  15 // Maximum depth of submenus allowed (e.g., 1 indicates that submenus are
  16 // allowed, but not sub-submenus).
  17 const int kMaxMenuDepth = 2;
  18 const uint32_t kMaxMenuEntries = 1000;
  19
  20 bool CheckMenu(int depth, const PP_Flash_Menu* menu);
  21 void FreeMenu(const PP_Flash_Menu* menu);
  22 void WriteMenu(IPC::Message* m, const PP_Flash_Menu* menu);
  23 PP_Flash_Menu* ReadMenu(int depth, const IPC::Message* m, PickleIterator* iter);
  24
  25 bool CheckMenuItem(int depth, const PP_Flash_MenuItem* item) {
  26   if (item->type == PP_FLASH_MENUITEM_TYPE_SUBMENU)
  27     return CheckMenu(depth, item->submenu);
  28   return true;
  29 }
  30
  31 bool CheckMenu(int depth, const PP_Flash_Menu* menu) {
  32   if (depth > kMaxMenuDepth || !menu)
  33     return false;
  34   ++depth;
  35
  36   if (menu->count && !menu->items)
  37     return false;
  38
  39   for (uint32_t i = 0; i < menu->count; ++i) {
  40     if (!CheckMenuItem(depth, menu->items + i))
  41       return false;
  42   }
  43   return true;
  44 }
  45
  46 void WriteMenuItem(IPC::Message* m, const PP_Flash_MenuItem* menu_item) {
  47   PP_Flash_MenuItem_Type type = menu_item->type;
  48   m->WriteUInt32(type);
  49   m->WriteString(menu_item->name ? menu_item->name : "");
  50   m->WriteInt(menu_item->id);
  51   IPC::ParamTraits<PP_Bool>::Write(m, menu_item->enabled);
  52   IPC::ParamTraits<PP_Bool>::Write(m, menu_item->checked);
  53   if (type == PP_FLASH_MENUITEM_TYPE_SUBMENU)
  54     WriteMenu(m, menu_item->submenu);
  55 }
  56
  57 void WriteMenu(IPC::Message* m, const PP_Flash_Menu* menu) {
  58   m->WriteUInt32(menu->count);
  59   for (uint32_t i = 0; i < menu->count; ++i)
  60     WriteMenuItem(m, menu->items + i);
  61 }
  62
  63 void FreeMenuItem(const PP_Flash_MenuItem* menu_item) {
  64   if (menu_item->name)
  65     delete [] menu_item->name;
  66   if (menu_item->submenu)
  67     FreeMenu(menu_item->submenu);
  68 }
  69
  70 void FreeMenu(const PP_Flash_Menu* menu) {
  71   if (menu->items) {
  72     for (uint32_t i = 0; i < menu->count; ++i)
  73       FreeMenuItem(menu->items + i);
  74     delete [] menu->items;
  75   }
  76   delete menu;
  77 }
  78
  79 bool ReadMenuItem(int depth,
  80                   const IPC::Message* m,
  81                   PickleIterator* iter,
  82                   PP_Flash_MenuItem* menu_item) {
  83   uint32_t type;
  84   if (!iter->ReadUInt32(&type))
  85     return false;
  86   if (type > PP_FLASH_MENUITEM_TYPE_SUBMENU)
  87     return false;
  88   menu_item->type = static_cast<PP_Flash_MenuItem_Type>(type);
  89   std::string name;
  90   if (!iter->ReadString(&name))
  91     return false;
  92   menu_item->name = new char[name.size() + 1];
  93   std::copy(name.begin(), name.end(), menu_item->name);
  94   menu_item->name[name.size()] = 0;
  95   if (!iter->ReadInt(&menu_item->id))
  96     return false;
  97   if (!IPC::ParamTraits<PP_Bool>::Read(m, iter, &menu_item->enabled))
  98     return false;
  99   if (!IPC::ParamTraits<PP_Bool>::Read(m, iter, &menu_item->checked))
 100     return false;
 101   if (type == PP_FLASH_MENUITEM_TYPE_SUBMENU) {
 102     menu_item->submenu = ReadMenu(depth, m, iter);
 103     if (!menu_item->submenu)
 104       return false;
 105   }
 106   return true;
 107 }
 108
 109 PP_Flash_Menu* ReadMenu(int depth,
 110                         const IPC::Message* m,
 111                         PickleIterator* iter) {
 112   if (depth > kMaxMenuDepth)
 113     return NULL;
 114   ++depth;
 115
 116   PP_Flash_Menu* menu = new PP_Flash_Menu;
 117   menu->items = NULL;
 118
 119   if (!iter->ReadUInt32(&menu->count)) {
 120     FreeMenu(menu);
 121     return NULL;
 122   }
 123
 124   if (menu->count == 0)
 125     return menu;
 126
 127   if (menu->count > kMaxMenuEntries) {
 128     FreeMenu(menu);
 129     return NULL;
 130   }
 131
 132   menu->items = new PP_Flash_MenuItem[menu->count];
 133   memset(menu->items, 0, sizeof(PP_Flash_MenuItem) * menu->count);
 134   for (uint32_t i = 0; i < menu->count; ++i) {
 135     if (!ReadMenuItem(depth, m, iter, menu->items + i)) {
 136       FreeMenu(menu);
 137       return NULL;
 138     }
 139   }
 140   return menu;
 141 }
 142
 143 }  // anonymous namespace
 144
 145 SerializedFlashMenu::SerializedFlashMenu()
 146     : pp_menu_(NULL),
 147       own_menu_(false) {
 148 }
 149
 150 SerializedFlashMenu::~SerializedFlashMenu() {
 151   if (own_menu_)
 152     FreeMenu(pp_menu_);
 153 }
 154
 155 bool SerializedFlashMenu::SetPPMenu(const PP_Flash_Menu* menu) {
 156   DCHECK(!pp_menu_);
 157   if (!CheckMenu(0, menu))
 158     return false;
 159   pp_menu_ = menu;
 160   own_menu_ = false;
 161   return true;
 162 }
 163
 164
 165 void SerializedFlashMenu::WriteToMessage(IPC::Message* m) const {
 166   WriteMenu(m, pp_menu_);
 167 }
 168
 169 bool SerializedFlashMenu::ReadFromMessage(const IPC::Message* m,
 170                                           PickleIterator* iter) {
 171   DCHECK(!pp_menu_);
 172   pp_menu_ = ReadMenu(0, m, iter);
 173   if (!pp_menu_)
 174     return false;
 175
 176   own_menu_ = true;
 177   return true;
 178 }
 179
 180 }  // namespace proxy
 181 }  // namespace ppapi