appshell_extensions.cpp

/*
 * Copyright (c) 2012 - present Adobe Systems Incorporated. All rights reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 *
 */

#include "appshell_extensions.h"

#include "appshell_extensions_platform.h"
#include "native_menu_model.h"
#include "appshell_node_process.h"
#include "config.h"

#ifdef OS_LINUX
#include "appshell/browser/main_context.h"
#include "appshell/browser/root_window_manager.h"
#endif

#include <algorithm>
#include "update.h"

extern std::vector<CefString> gDroppedFiles;
extern int g_remote_debugging_port;
extern std::string g_get_remote_debugging_port_error;

namespace appshell_extensions {

class ProcessMessageDelegate : public ClientHandler::ProcessMessageDelegate {
public:
    ProcessMessageDelegate()
    {
    }

    // From ClientHandler::ProcessMessageDelegate.
    virtual bool OnProcessMessageReceived(
                      CefRefPtr<ClientHandler> handler,
                      CefRefPtr<CefBrowser> browser,
                      CefProcessId source_process,
                      CefRefPtr<CefProcessMessage> message) OVERRIDE {
        std::string message_name = message->GetName();
        CefRefPtr<CefListValue> argList = message->GetArgumentList();
        int32 callbackId = -1;
        int32 error = NO_ERROR;
        std::string errInfo;
        CefRefPtr<CefProcessMessage> response = 
            CefProcessMessage::Create("invokeCallback");
        CefRefPtr<CefListValue> responseArgs = response->GetArgumentList();
        
        // V8 extension messages are handled here. These messages come from the 
        // render process thread (in client_app.cpp), and have the following format:
        //   name - the name of the native function to call
        //   argument0 - the id of this message. This id is passed back to the
        //               render process in order to execute callbacks
        //   argument1 - argumentN - the arguments for the function
        //
        // Note: Functions without callback can be specified, but they *cannot*
        // take any arguments.
        
        // If we have any arguments, the first is the callbackId
        if (argList->GetSize() > 0) {
            callbackId = argList->GetInt(0);
            
            if (callbackId != -1)
                responseArgs->SetInt(0, callbackId);
        }
        
        if (message_name == "OpenLiveBrowser") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - argURL
            //  2: bool - enableRemoteDebugging
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_BOOL) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString argURL = argList->GetString(1);
                bool enableRemoteDebugging = argList->GetBool(2);
                error = OpenLiveBrowser(argURL, enableRemoteDebugging);
            }
            
        } else if (message_name == "CloseLiveBrowser") {
            // Parameters
            //  0: int32 - callback id
            if (argList->GetSize() != 1) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                CloseLiveBrowser(browser, response);
            
                // Skip standard callback handling. CloseLiveBrowser fires the
                // callback asynchronously.
                return true;
            }
        } else if (message_name == "ShowOpenDialog") {
            // Parameters:
            //  0: int32 - callback id
            //  1: bool - allowMultipleSelection
            //  2: bool - chooseDirectory
            //  3: string - title
            //  4: string - initialPath
            //  5: string - fileTypes (space-delimited string)
            if (argList->GetSize() != 6 ||
                argList->GetType(1) != VTYPE_BOOL ||
                argList->GetType(2) != VTYPE_BOOL ||
                argList->GetType(3) != VTYPE_STRING ||
                argList->GetType(4) != VTYPE_STRING ||
                argList->GetType(5) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
           
            if (error == NO_ERROR) {
                bool allowMultipleSelection = argList->GetBool(1);
                bool chooseDirectory = argList->GetBool(2);
                ExtensionString title = argList->GetString(3);
                ExtensionString initialPath = argList->GetString(4);
                ExtensionString fileTypes = argList->GetString(5);
                
#ifdef OS_MACOSX
                ShowOpenDialog(allowMultipleSelection,
                               chooseDirectory,
                               title,
                               initialPath,
                               fileTypes,
                               browser,
                               response);
                
                // Skip standard callback handling. ShowOpenDialog fires the
                // callback asynchronously.
                
                return true;
#else
                CefRefPtr<CefListValue> selectedFiles = CefListValue::Create();
                error = ShowOpenDialog(allowMultipleSelection,
                                       chooseDirectory,
                                       title,
                                       initialPath,
                                       fileTypes,
                                       selectedFiles);
                // Set response args for this function
                responseArgs->SetList(2, selectedFiles);
#endif
                
            }
            
        } else if (message_name == "ShowSaveDialog") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - title
            //  2: string - initialPath
            //  3: string - poposedNewFilename
            if (argList->GetSize() != 4 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING ||
                argList->GetType(3) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }

            if (error == NO_ERROR) {
                ExtensionString title = argList->GetString(1);
                ExtensionString initialPath = argList->GetString(2);
                ExtensionString proposedNewFilename = argList->GetString(3);
                
#ifdef OS_MACOSX
                // Skip standard callback handling. ShowSaveDialog fires the
                // callback asynchronously.
                ShowSaveDialog(title,
                               initialPath,
                               proposedNewFilename,
                               browser,
                               response);
                return true;
#else
                ExtensionString newFilePath;
                error = ShowSaveDialog(title,
                                       initialPath,
                                       proposedNewFilename,
                                       newFilePath);
                
                // Set response args for this function
                responseArgs->SetString(2, newFilePath);
#endif
            }

        } else if (message_name == "IsNetworkDrive") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - directory path
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            bool isRemote = false;
            if (error == NO_ERROR) {
                ExtensionString path = argList->GetString(1);                
                error = IsNetworkDrive(path, isRemote);
            }
            
            // Set response args for this function
            responseArgs->SetBool(2, isRemote);
        } else if (message_name == "ReadDir") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - directory path
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            CefRefPtr<CefListValue> directoryContents = CefListValue::Create();
            
            if (error == NO_ERROR) {
                ExtensionString path = argList->GetString(1);
                
                error = ReadDir(path, directoryContents);
            }
            
            // Set response args for this function
            responseArgs->SetList(2, directoryContents);
        } else if (message_name == "MakeDir") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - directory path
            //  2: number - mode
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_INT) {
                error = ERR_INVALID_PARAMS;
            }
          
            if (error == NO_ERROR) {
                ExtensionString pathname = argList->GetString(1);
                int32 mode = argList->GetInt(2);
              
                error = MakeDir(pathname, mode);
            }
            // No additional response args for this function
        } else if (message_name == "Rename") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - old path
            //  2: string - new path
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
          
            if (error == NO_ERROR) {
                ExtensionString oldName = argList->GetString(1);
                ExtensionString newName = argList->GetString(2);
            
                error = Rename(oldName, newName);
            }
          // No additional response args for this function
        } else if (message_name == "GetFileInfo") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString filename = argList->GetString(1);
                ExtensionString realPath;
                uint32 modtime;
                double size;
                bool isDir;
                
                error = GetFileInfo(filename, modtime, isDir, size, realPath);
                
                // Set response args for this function
                responseArgs->SetInt(2, modtime);
                responseArgs->SetBool(3, isDir);
                responseArgs->SetInt(4, size);
                responseArgs->SetString(5, realPath);
            }
        } else if (message_name == "ReadFile") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            //  2: string - encoding
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString filename = argList->GetString(1);
                ExtensionString encoding = argList->GetString(2);
                std::string contents = "";
                bool preserveBOM = false;
                
                error = ReadFile(filename, encoding, contents, preserveBOM);
                
                // Set response args for this function
                responseArgs->SetString(2, contents);
                responseArgs->SetString(3, encoding);
                responseArgs->SetBool(4, preserveBOM);
            }
        } else if (message_name == "WriteFile") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            //  2: string - data
            //  3: string - encoding
            if (argList->GetSize() != 5 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING ||
                argList->GetType(3) != VTYPE_STRING ||
                argList->GetType(4) != VTYPE_BOOL) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString filename = argList->GetString(1);
                std::string contents = argList->GetString(2);
                ExtensionString encoding = argList->GetString(3);
                bool preserveBOM = argList->GetBool(4);
                
                error = WriteFile(filename, contents, encoding, preserveBOM);
                // No additional response args for this function
            }
        } else if (message_name == "SetPosixPermissions") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            //  2: int - mode
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_INT) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString filename = argList->GetString(1);
                int32 mode = argList->GetInt(2);
                
                error = SetPosixPermissions(filename, mode);
                
                // No additional response args for this function
            }
        } else if (message_name == "DeleteFileOrDirectory") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString filename = argList->GetString(1);
                
                error = DeleteFileOrDirectory(filename);
                
                // No additional response args for this function
            }
        } else if (message_name == "MoveFileOrDirectoryToTrash") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - path
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString path = argList->GetString(1);
                
                MoveFileOrDirectoryToTrash(path, browser, response);
                
                // Skip standard callback handling. MoveFileOrDirectoryToTrash fires the
                // callback asynchronously.
                return true;
            }
        } else if (message_name == "ShowDeveloperTools") {
            // Parameters - none
            CefWindowInfo wi;
            CefBrowserSettings settings;

            #if defined(OS_WIN)
                wi.SetAsPopup(NULL, "DevTools");
            #elif defined(OS_LINUX)
                handler->ShowDevTools(browser, CefPoint());
            #endif

            #ifndef OS_LINUX
                browser->GetHost()->ShowDevTools(wi, browser->GetHost()->GetClient(), settings, CefPoint());
            #endif

        } else if (message_name == "GetNodeState") {
            // Parameters:
            //  0: int32 - callback id
            if (argList->GetSize() != 1) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                int32 port = 0;
                int32 portOrErr = getNodeState();
                if (portOrErr < 0) { // there is an error
                    error = portOrErr;
                } else {
                    port = portOrErr;
                    error = NO_ERROR;
                }
                responseArgs->SetInt(2, port);
            }
            
        } else if (message_name == "QuitApplication") {
            // Parameters - none

            // The DispatchCloseToNextBrowser() call initiates a quit sequence. The app will
            // quit if all browser windows are closed.
            #ifdef OS_LINUX
                if(client::MainContext::Get() && 
                    client::MainContext::Get()->GetRootWindowManager()){
                    client::MainContext::Get()->GetRootWindowManager()->DispatchCloseToNextWindow();
                }
            #else
                handler->DispatchCloseToNextBrowser();
            #endif
            

        } else if (message_name == "AbortQuit") {
            // Parameters - none
          
            handler->AbortQuit();
        } else if (message_name == "OpenURLInDefaultBrowser") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - url
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString url = argList->GetString(1);
                
                error = OpenURLInDefaultBrowser(url);
                
                // No additional response args for this function
            }
        } else if (message_name == "ShowOSFolder") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - path
            
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
          
            if (error == NO_ERROR) {
                ExtensionString path = argList->GetString(1);
                error = ShowFolderInOSWindow(path);
            }
        } else if (message_name == "GetPendingFilesToOpen") {
            // Parameters:
            //  0: int32 - callback id
            if (argList->GetSize() != 1) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString files;
                error = GetPendingFilesToOpen(files);
                responseArgs->SetString(2, files.c_str());
            }
        } else if (message_name == "CopyFile") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - filename
            //  2: string - dest filename
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString src = argList->GetString(1);
                ExtensionString dest = argList->GetString(2);
                
                error = CopyFile(src, dest);
                // No additional response args for this function
            }
        } else if (message_name == "SetUpdateParams") {
			// Parameters:
			//  0: int32 - callback id
			//  1: string - update parameters json object

			size_t numArgs = argList->GetSize();
			if (numArgs < 2 ||
				argList->GetType(1) != VTYPE_STRING) {
				error = ERR_INVALID_PARAMS;
			}
            if(error == NO_ERROR){
                CefString updateJson = argList->GetString(1);
                error = SetInstallerCommandLineArgs(updateJson);
            }
		} else if (message_name == "GetDroppedFiles") {
            // Parameters:
            //  0: int32 - callback id
            if (argList->GetSize() != 1) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                std::wstring files;
                
                files = L"[";
                for (unsigned int i = 0; i < gDroppedFiles.size(); i++) {
                    std::wstring file(gDroppedFiles[i]);
                    // Convert windows paths to unix paths
                    replace(file.begin(), file.end(), '\\', '/');
                    files += L"\"";
                    files += file;
                    files += L"\"";
                    if (i < gDroppedFiles.size() - 1) {
                        files += L", ";
                    }
                }
                files += L"]";
                gDroppedFiles.clear();
                
                responseArgs->SetString(2, files.c_str());
            }
            
        } else if (message_name == "AddMenu") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - menuTitle to display
            //  2: string - menu/command ID
            //  3: string - position - first, last, before, after
            //  4: string - relativeID - ID of other element relative to which this should be positioned (for position before and after)
            if (argList->GetSize() != 5 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING ||
                argList->GetType(3) != VTYPE_STRING ||
                argList->GetType(4) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString menuTitle = argList->GetString(1);
                ExtensionString command = CefString(argList->GetString(2));
                ExtensionString position = CefString(argList->GetString(3));
                ExtensionString relativeId = CefString(argList->GetString(4));
                
                error = AddMenu(browser, menuTitle, command, position, relativeId);
                // No additional response args for this function
            }
        } else if (message_name == "AddMenuItem") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - parent menu this is part of
            //  2: string - menuTitle to display
            //  3: string - command ID
            //  4: string - keyboard shortcut
            //  5: string - display string
            //  6: string - position - first, last, before, after
            //  7: string - relativeID - ID of other element relative to which this should be positioned (for position before and after)
            if (argList->GetSize() != 8 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING ||
                argList->GetType(3) != VTYPE_STRING ||
                argList->GetType(4) != VTYPE_STRING ||
                argList->GetType(5) != VTYPE_STRING ||
                argList->GetType(6) != VTYPE_STRING ||
                argList->GetType(7) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString parentCommand = argList->GetString(1);
                ExtensionString menuTitle = argList->GetString(2);
                ExtensionString command = argList->GetString(3);
                ExtensionString key = argList->GetString(4);
                ExtensionString displayStr = argList->GetString(5);
                ExtensionString position = argList->GetString(6);
                ExtensionString relativeId = argList->GetString(7);

                error = AddMenuItem(browser, parentCommand, menuTitle, command, key, displayStr, position, relativeId);
                // No additional response args for this function
            }
        } else if (message_name == "RemoveMenu") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - command ID
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId;
                commandId = argList->GetString(1);
                error = RemoveMenu(browser, commandId);
            }
            // No response args for this function
        } else if (message_name == "RemoveMenuItem") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - command ID
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId;
                commandId = argList->GetString(1);
                error = RemoveMenuItem(browser, commandId);
            }
            // No response args for this function
        } else if (message_name == "GetMenuItemState") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - menu/command ID
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId = CefString(argList->GetString(1));
                ExtensionString menuTitle;
                bool checked, enabled;
                int index;
                error = GetMenuItemState(browser, commandId, enabled, checked, index);
                responseArgs->SetBool(2, enabled);
                responseArgs->SetBool(3, checked);
                responseArgs->SetInt(4, index);
            }
        }  else if(message_name == "SetMenuItemState") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - commandName
            //  2: bool - enabled
            //  3: bool - checked
            if (argList->GetSize() != 4 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_BOOL ||
                argList->GetType(3) != VTYPE_BOOL) {
                error = ERR_INVALID_PARAMS;
            }

            if (error == NO_ERROR) {
                ExtensionString command = argList->GetString(1);
                bool enabled = argList->GetBool(2);
                bool checked = argList->GetBool(3);
                error = NativeMenuModel::getInstance(getMenuParent(browser)).setMenuItemState(command, enabled, checked);
                if (error == NO_ERROR) {
                    error = SetMenuItemState(browser, command, enabled, checked);
                }
            }
        } else if (message_name == "SetMenuTitle") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - menu/command ID
            //  2: string - menuTitle to display
            if (argList->GetSize() != 3 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING) {
                    error = ERR_INVALID_PARAMS;
            }

            if (error == NO_ERROR) {
                ExtensionString command = CefString(argList->GetString(1));
                ExtensionString menuTitle = argList->GetString(2);

                error = SetMenuTitle(browser, command, menuTitle);
                // No additional response args for this function
            }
        }  else if (message_name == "GetMenuTitle") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - menu/command ID
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId = CefString(argList->GetString(1));
                ExtensionString menuTitle;
                error = GetMenuTitle(browser, commandId, menuTitle);
                responseArgs->SetString(2, menuTitle);
            }
        } else if (message_name == "SetMenuItemShortcut") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - command ID
            //  2: string - shortcut
            //  3: string - display string
            if (argList->GetSize() != 4 ||
                argList->GetType(1) != VTYPE_STRING ||
                argList->GetType(2) != VTYPE_STRING ||
                argList->GetType(3) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId = argList->GetString(1);
                ExtensionString shortcut = argList->GetString(2);
                ExtensionString displayStr = argList->GetString(3);
                
                error = SetMenuItemShortcut(browser, commandId, shortcut, displayStr);
                // No additional response args for this function
            }
        } else if (message_name == "GetMenuPosition") {
            // Parameters:
            //  0: int32 - callback id
            //  1: string - menu/command ID
            if (argList->GetSize() != 2 ||
                argList->GetType(1) != VTYPE_STRING) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                ExtensionString commandId;
                ExtensionString parentId;
                int index;
                commandId = argList->GetString(1);
                error = GetMenuPosition(browser, commandId, parentId, index);
                responseArgs->SetString(2, parentId);
                responseArgs->SetInt(3, index);
            }
        } else if (message_name == "DragWindow") {     
            // Parameters: none       
            DragWindow(browser);
        } else if (message_name == "GetZoomLevel") {
            // Parameters:
            //  0: int32 - callback id
            double zoomLevel = browser->GetHost()->GetZoomLevel();

            responseArgs->SetDouble(2, zoomLevel);
        } else if (message_name == "SetZoomLevel") {
            // Parameters:
            //  0: int32 - callback id
            //  1: int32 - zoom level

            if (argList->GetSize() != 2 ||
                !(argList->GetType(1) == VTYPE_INT || argList->GetType(1) == VTYPE_DOUBLE)) {
                error = ERR_INVALID_PARAMS;
            }

            if (error == NO_ERROR) {
                // cast to double
                double zoomLevel = 1;
                
                if (argList->GetType(1) == VTYPE_DOUBLE) {
                    zoomLevel = argList->GetDouble(1);
                } else {
                    zoomLevel = argList->GetInt(1);
                }

                browser->GetHost()->SetZoomLevel(zoomLevel);
            }
        }
        else if (message_name == "InstallCommandLineTools") {
            // Parameters:
            //  0: int32 - callback id
            if (argList->GetSize() != 1) {
                error = ERR_INVALID_PARAMS;
            }
            
            if (error == NO_ERROR) {
                error = InstallCommandLineTools();
            }

		} else if (message_name == "GetMachineHash") {
			// Parameters:
			//  0: int32 - callback id

			responseArgs->SetString(2, GetSystemUniqueID());
		} 
        else if (message_name == "ReadDirWithStats") {
            // Parameters:
            //  0: int32 - callback id
            
            CefRefPtr<CefListValue> uberDict    = CefListValue::Create();
            CefRefPtr<CefListValue> dirContents = CefListValue::Create();
            CefRefPtr<CefListValue> allStats = CefListValue::Create();
            
            ExtensionString path = argList->GetString(1);
            ReadDir(path, dirContents);
            
            // Now we iterator through the contents of directoryContents.
            size_t theSize = dirContents->GetSize();
            for ( size_t iFileEntry = 0; iFileEntry < theSize ; ++iFileEntry) {
                CefRefPtr<CefListValue> fileStats = CefListValue::Create();

                #ifdef OS_WIN
                    ExtensionString theFile  = path + L"/";
                #else
                    ExtensionString theFile  = path + "/";
                #endif

                ExtensionString fileName = dirContents->GetString(iFileEntry);
                theFile = theFile + fileName;
                
                ExtensionString realPath;
                uint32 modtime;
                double size;
                bool isDir;
                GetFileInfo(theFile, modtime, isDir, size, realPath);
                
                fileStats->SetInt(0, modtime);
                fileStats->SetBool(1, isDir);
                fileStats->SetInt(2, size);
                fileStats->SetString(3, realPath);
                
                allStats->SetList(iFileEntry, fileStats);
                
            }
            
            uberDict->SetList(0, dirContents);
            uberDict->SetList(1, allStats);
            responseArgs->SetList(2, uberDict);
        } else if (message_name == "GetRemoteDebuggingPort") {
            if (g_get_remote_debugging_port_error.empty() && g_remote_debugging_port > 0) {
                responseArgs->SetInt(2, g_remote_debugging_port);
            }
            else {
                responseArgs->SetNull(2);
                errInfo = g_get_remote_debugging_port_error;
            }
        }

        else {
            fprintf(stderr, "Native function not implemented yet: %s\n", message_name.c_str());
            return false;
        }
      
        if (callbackId != -1) {
            if (errInfo.empty()) {
                responseArgs->SetInt(1, error);
            }
            else {
                responseArgs->SetString(1, errInfo);
            }

            // Send response
            browser->SendProcessMessage(PID_RENDERER, response);
        }
      
        return true;
    }
  
    IMPLEMENT_REFCOUNTING(ProcessMessageDelegate);
};
    
void CreateProcessMessageDelegates(ClientHandler::ProcessMessageDelegateSet& delegates) {
    delegates.insert(new ProcessMessageDelegate);
}

} // namespace appshell_extensions