void recvProcessDebugMappings(NETQUEUE queue) { bool val = false; NETbeginDecode(queue, GAME_DEBUG_MODE); NETbool(&val); NETend(); bool oldDebugMode = getDebugMappingStatus(); processDebugMappings(queue.index, val); bool newDebugMode = getDebugMappingStatus(); char const *cmsg; if (val) { sasprintf((char**)&cmsg, _("%s wants to enable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str()); } else { sasprintf((char**)&cmsg, _("%s wants to disable debug mode. Enabled: %s, Disabled: %s."), getPlayerName(queue.index), getWantedDebugMappingStatuses(true).c_str(), getWantedDebugMappingStatuses(false).c_str()); } addConsoleMessage(cmsg, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); if (!oldDebugMode && newDebugMode) { addConsoleMessage(_("Debug mode now enabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else if (oldDebugMode && !newDebugMode) { addConsoleMessage(_("Debug mode now disabled!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } }
static QScriptValue js_gameOverMessage(QScriptContext *context, QScriptEngine *engine) { int player = engine->globalObject().property("me").toInt32(); const MESSAGE_TYPE msgType = MSG_MISSION; // always bool gameWon = context->argument(0).toBool(); VIEWDATA *psViewData; if (gameWon) { psViewData = getViewData("WIN"); addConsoleMessage(_("YOU ARE VICTORIOUS!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else { psViewData = getViewData("WIN"); addConsoleMessage(_("YOU WERE DEFEATED!"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } ASSERT(psViewData, "Viewdata not found"); MESSAGE *psMessage = addMessage(msgType, false, player); if (psMessage) { //set the data psMessage->pViewData = (MSG_VIEWDATA *)psViewData; displayImmediateMessage(psMessage); stopReticuleButtonFlash(IDRET_INTEL_MAP); //we need to set this here so the VIDEO_QUIT callback is not called setScriptWinLoseVideo(gameWon ? PLAY_WIN : PLAY_LOSE); } displayGameOver(gameWon); if (challengeActive) { updateChallenge(gameWon); } return QScriptValue(); }
// //////////////////////////////////////////////////////////////////////////// // A remote player has left the game bool MultiPlayerLeave(UDWORD playerIndex) { char buf[255]; if (playerIndex >= MAX_PLAYERS) { ASSERT(false, "Bad player number"); return false; } NETlogEntry("Player leaving game", SYNC_FLAG, playerIndex); debug(LOG_NET,"** Player %u [%s], has left the game at game time %u.", playerIndex, getPlayerName(playerIndex), gameTime); ssprintf(buf, _("%s has Left the Game"), getPlayerName(playerIndex)); if (ingame.localJoiningInProgress) { clearPlayer(playerIndex, false); } else if (NetPlay.isHost) // If hosting, and game has started (not in pre-game lobby screen, that is). { sendPlayerLeft(playerIndex); } game.skDiff[playerIndex] = 0; addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); if (NetPlay.players[playerIndex].wzFile.isSending) { char buf[256]; ssprintf(buf, _("File transfer has been aborted for %d.") , playerIndex); addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); debug(LOG_INFO, "=== File has been aborted for %d ===", playerIndex); NetPlay.players[playerIndex].wzFile.isSending = false; NetPlay.players[playerIndex].needFile = false; } NetPlay.players[playerIndex].kick = true; // Don't wait for GAME_GAME_TIME messages from them. if (widgGetFromID(psWScreen, IDRET_FORM)) { audio_QueueTrack(ID_CLAN_EXIT); } // fire script callback to reassign skirmish players. CBPlayerLeft = playerIndex; eventFireCallbackTrigger((TRIGGER_TYPE)CALL_PLAYERLEFT); netPlayersUpdated = true; return true; }
/** Writes a screenshot of the current frame to file. * * Performs the actual work of writing the frame currently displayed on screen * to the filename specified by screenDumpToDisk(). * * @NOTE This function will only dump a screenshot to file if it was requested * by screenDumpToDisk(). * * \sa screenDumpToDisk() */ void screenDoDumpToDiskIfRequired(void) { const char* fileName = screendump_filename; iV_Image image = { 0, 0, 8, NULL }; if (!screendump_required) return; debug(LOG_3D, "Saving screenshot %s", fileName); image.width = screenWidth; image.height = screenHeight; image.bmp = (unsigned char *)malloc(channelsPerPixel * image.width * image.height); glPixelStorei(GL_PACK_ALIGNMENT, 1); glReadPixels(0, 0, image.width, image.height, GL_RGB, GL_UNSIGNED_BYTE, image.bmp); iV_saveImage_PNG(fileName, &image); iV_saveImage_JPEG(fileName, &image); // display message to user about screenshot snprintf(ConsoleString,sizeof(ConsoleString),"Screenshot %s saved!",fileName); addConsoleMessage(ConsoleString, LEFT_JUSTIFY,SYSTEM_MESSAGE); if (image.bmp) { free(image.bmp); } screendump_required = false; }
// TODO, should cover scrShowConsoleText, scrAddConsoleText, scrTagConsoleText and scrConsole static QScriptValue js_console(QScriptContext *context, QScriptEngine *engine) { int player = engine->globalObject().property("me").toInt32(); if (player == selectedPlayer) { QString result; for (int i = 0; i < context->argumentCount(); ++i) { if (i != 0) { result.append(QLatin1String(" ")); } QString s = context->argument(i).toString(); if (context->state() == QScriptContext::ExceptionState) { break; } result.append(s); } //permitNewConsoleMessages(true); //setConsolePermanence(true,true); addConsoleMessage(result.toAscii().constData(), CENTRE_JUSTIFY, SYSTEM_MESSAGE); //permitNewConsoleMessages(false); } return QScriptValue(); }
void ExecutionContext::parseAndSetReferrerPolicy(const String& policies, bool supportLegacyKeywords) { ReferrerPolicy referrerPolicy = ReferrerPolicyDefault; Vector<String> tokens; policies.split(',', true, tokens); for (const auto& token : tokens) { ReferrerPolicy currentResult; if ((supportLegacyKeywords ? SecurityPolicy::referrerPolicyFromStringWithLegacyKeywords( token, ¤tResult) : SecurityPolicy::referrerPolicyFromString(token, ¤tResult))) { referrerPolicy = currentResult; } } if (referrerPolicy == ReferrerPolicyDefault) { addConsoleMessage(ConsoleMessage::create( RenderingMessageSource, ErrorMessageLevel, "Failed to set referrer policy: The value '" + policies + "' is not one of " + (supportLegacyKeywords ? "'always', 'default', 'never', 'origin-when-crossorigin', " : "") + "'no-referrer', 'no-referrer-when-downgrade', 'origin', " "'origin-when-cross-origin', or 'unsafe-url'. The referrer policy " "has been left unchanged.")); return; } setReferrerPolicy(referrerPolicy); }
// Stop droid driving mode. // void StopDriverMode(void) { DROID *psDroid; if(psDrivenDroid != NULL) { debug( LOG_NEVER, "Drive mode canceled\n" ); addConsoleMessage("Driver mode canceled.", LEFT_JUSTIFY,SYSTEM_MESSAGE); // audio_StopObjTrack(psDrivenDroid,ID_SOUND_SMALL_DROID_RUN); psDrivenDroid = NULL; for(psDroid = apsDroidLists[selectedPlayer]; psDroid; psDroid = psDroid->psNext) { if( (psDroid->sMove.Status == MOVEDRIVE) ) { ASSERT( (psDroid->droidType != DROID_TRANSPORTER),"Tried to control a transporter" ); secondarySetState(psDroid, DSO_HALTTYPE, DSS_HALT_GUARD); psDroid->sMove.Status = MOVEINACTIVE; } } } setDrivingStatus(false); driveInitVars(false); // reset everything again DriveControlEnabled = false; DirectControl = false; }
// //////////////////////////////////////////////////////////////////////////// // Setup Stuff for a new player. void setupNewPlayer(UDWORD player) { UDWORD i; ingame.PingTimes[player] = 0; // Reset ping time ingame.JoiningInProgress[player] = true; // Note that player is now joining ingame.DataIntegrity[player] = false; for (i = 0; i < MAX_PLAYERS; i++) // Set all alliances to broken { alliances[selectedPlayer][i] = ALLIANCE_BROKEN; alliances[i][selectedPlayer] = ALLIANCE_BROKEN; } resetMultiVisibility(player); // set visibility flags. setMultiStats(player, getMultiStats(player), true); // get the players score if (selectedPlayer != player) { char buf[255]; ssprintf(buf, _("%s is joining the game"), getPlayerName(player)); addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } }
/** This function adds the droid to the command group commanded by psCommander. * It creates a group if it doesn't exist. * If the group is not full, it adds the droid to it and sets all the droid's states and orders to the group's. */ void cmdDroidAddDroid(DROID *psCommander, DROID *psDroid) { DROID_GROUP *psGroup; if (psCommander->psGroup == NULL) { psGroup = grpCreate(); psGroup->add(psCommander); psDroid->group = UBYTE_MAX; } if (psCommander->psGroup->getNumMembers() < cmdDroidMaxGroup(psCommander)) { psCommander->psGroup->add(psDroid); psDroid->group = UBYTE_MAX; // set the secondary states for the unit secondarySetState(psDroid, DSO_REPAIR_LEVEL, (SECONDARY_STATE)(psCommander->secondaryOrder & DSS_REPLEV_MASK), ModeImmediate); secondarySetState(psDroid, DSO_ATTACK_LEVEL, (SECONDARY_STATE)(psCommander->secondaryOrder & DSS_ALEV_MASK), ModeImmediate); orderDroidObj(psDroid, DORDER_GUARD, (BASE_OBJECT *)psCommander, ModeImmediate); } else { audio_PlayTrack( ID_SOUND_BUILD_FAIL ); addConsoleMessage(_("Commander needs a higher level to command more units"), DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } }
void runLimitScreen(void) { UDWORD i, id, statid; frontendMultiMessages(); // network stuff. id = widgRunScreen(psWScreen); // Run the current set of widgets // sliders if((id > IDLIMITS_ENTRIES_START) && (id< IDLIMITS_ENTRIES_END)) { statid = widgGetFromID(psWScreen,id-1)->UserData ; if(statid) { asStructLimits[0][statid].limit = (UBYTE) ((W_SLIDER*)(widgGetFromID(psWScreen,id)))->pos; } } else { // icons that are always about. switch(id) { case IDLIMITS_RETURN: // reset the sliders.. for (i = 0; i < numStructureStats ; ++i) { asStructLimits[0][i].limit = asStructLimits[0][i].globalLimit; } // free limiter structure freeLimitSet(); //inform others sendOptions(); eventReset(); changeTitleMode(MULTIOPTION); // make some noize. if(!ingame.localOptionsReceived) { addConsoleMessage(_("Limits reset to default values"),DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } else { sendTextMessage("Limits Reset To Default Values",true); } break; case IDLIMITS_OK: resetReadyStatus(false); createLimitSet(); changeTitleMode(MULTIOPTION); break; default: break; } } widgDisplayScreen(psWScreen); // show the widgets currently running }
// //////////////////////////////////////////////////////////////////////////// // Network File packet processor. bool recvMapFileRequested(NETQUEUE queue) { //char mapStr[256],mapName[256],fixedname[256]; uint32_t player; PHYSFS_sint64 fileSize_64; PHYSFS_file *pFileHandle; if(!NetPlay.isHost) // only host should act { ASSERT(false, "Host only routine detected for client!"); return false; } // Check to see who wants the file NETbeginDecode(queue, NET_FILE_REQUESTED); NETuint32_t(&player); NETend(); if (!NetPlay.players[player].wzFile.isSending) { NetPlay.players[player].needFile = true; NetPlay.players[player].wzFile.isCancelled = false; NetPlay.players[player].wzFile.isSending = true; LEVEL_DATASET *mapData = levFindDataSet(game.map, &game.hash); addConsoleMessage("Map was requested: SENDING MAP!",DEFAULT_JUSTIFY, SYSTEM_MESSAGE); char *mapStr = mapData->realFileName; debug(LOG_NET, "Map was requested. Looking for %s", mapStr); // Checking to see if file is available... pFileHandle = PHYSFS_openRead(mapStr); if (pFileHandle == NULL) { debug(LOG_ERROR, "Failed to open %s for reading: %s", mapStr, PHYSFS_getLastError()); debug(LOG_FATAL, "You have a map (%s) that can't be located.\n\nMake sure it is in the correct directory and or format! (No map packs!)", mapStr); // NOTE: if we get here, then the game is basically over, The host can't send the file for whatever reason... // Which also means, that we can't continue. debug(LOG_NET, "***Host has a file issue, and is being forced to quit!***"); NETbeginEncode(NETbroadcastQueue(), NET_HOST_DROPPED); NETend(); abort(); } // get the file's size. fileSize_64 = PHYSFS_fileLength(pFileHandle); debug(LOG_NET, "File is valid, sending [directory: %s] %s to client %u", PHYSFS_getRealDir(mapStr), mapStr, player); NetPlay.players[player].wzFile.pFileHandle = pFileHandle; NetPlay.players[player].wzFile.fileSize_32 = (int32_t) fileSize_64; //we don't support 64bit int nettypes. NetPlay.players[player].wzFile.currPos = 0; NETsendFile(game.map, game.hash, player); } return true; }
// While not the perfect place for this, it has to do when a HOST joins (hosts) game // unfortunatly, we don't get the message until after the setup is done. void ShowMOTD(void) { char buf[250] = { '\0' }; // when HOST joins the game, show server MOTD message first addConsoleMessage(_("Server message:"), DEFAULT_JUSTIFY, NOTIFY_MESSAGE); addConsoleMessage(NetPlay.MOTD, DEFAULT_JUSTIFY, NOTIFY_MESSAGE); if (NetPlay.HaveUpgrade) { audio_PlayTrack(ID_SOUND_BUILD_FAIL); ssprintf(buf, _("There is an update to the game, please visit http://wz2100.net to download new version.")); addConsoleMessage(buf, DEFAULT_JUSTIFY, NOTIFY_MESSAGE); } else { audio_PlayTrack(FE_AUDIO_MESSAGEEND); } }
static void addConsolePlayerLeftMessage(unsigned playerIndex) { if (selectedPlayer != playerIndex) { char buf[256]; ssprintf(buf, _("%s has Left the Game"), getPlayerName(playerIndex)); addConsoleMessage(buf, DEFAULT_JUSTIFY, SYSTEM_MESSAGE); } }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, PassRefPtrWillBeRawPtr<ScriptCallStack> callStack, unsigned long requestIdentifier) { if (type == ClearMessageType) { ErrorString error; clearMessages(&error); } addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, callStack, requestIdentifier))); }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, ScriptState* state, PassRefPtr<ScriptArguments> arguments, unsigned long requestIdentifier) { if (type == ClearMessageType) { ErrorString error; clearMessages(&error); } addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, arguments, state, requestIdentifier))); }
UDWORD selDroidSelection( UDWORD player, SELECTION_CLASS droidClass, SELECTIONTYPE droidType, BOOL bOnScreen ) { UDWORD retVal; char selInfo[255]; /* So far, we haven't selected any */ retVal = 0; /* Establish the class of selection */ switch(droidClass) { case DS_ALL_UNITS: retVal = selSelectAllUnits(player,bOnScreen); break; case DS_BY_TYPE: switch(droidType) { case DST_VTOL: retVal = selSelectAllSameProp(player,PROPULSION_TYPE_LIFT,bOnScreen); break; case DST_HOVER: retVal = selSelectAllSameProp(player,PROPULSION_TYPE_HOVER,bOnScreen); break; case DST_WHEELED: retVal = selSelectAllSameProp(player,PROPULSION_TYPE_WHEELED,bOnScreen); break; case DST_TRACKED: retVal = selSelectAllSameProp(player,PROPULSION_TYPE_TRACKED,bOnScreen); break; case DST_HALF_TRACKED: retVal = selSelectAllSameProp(player,PROPULSION_TYPE_HALF_TRACKED,bOnScreen); break; case DST_ALL_COMBAT: retVal = selSelectAllCombat(player,bOnScreen); break; case DST_ALL_DAMAGED: retVal = selSelectAllDamaged(player,bOnScreen); break; case DST_ALL_SAME: retVal = selSelectAllSame(player,bOnScreen); break; default: ASSERT( false,"Invalid selection type in uniDroidSelection" ); } break; default: ASSERT( false,"Invalid selection attempt in uniDroidSelection" ); break; } /* Send back the return value */ snprintf(selInfo, sizeof(selInfo), ngettext("%u unit selected", "%u units selected", retVal), retVal); addConsoleMessage(selInfo, RIGHT_JUSTIFY,SYSTEM_MESSAGE); return retVal; }
void InspectorConsoleAgent::didReceiveResponse(unsigned long identifier, const ResourceResponse& response) { if (!m_inspectorAgent->enabled()) return; if (response.httpStatusCode() >= 400) { String message = "Failed to load resource: the server responded with a status of " + String::number(response.httpStatusCode()) + " (" + response.httpStatusText() + ')'; addConsoleMessage(adoptPtr(new ConsoleMessage(OtherMessageSource, NetworkErrorMessageType, ErrorMessageLevel, message, response.url().string(), identifier))); } }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& scriptId, unsigned lineNumber, unsigned columnNumber, ScriptState* state, unsigned long requestIdentifier) { if (type == ClearMessageType) { ErrorString error; clearMessages(&error); } bool canGenerateCallStack = !isWorkerAgent() && m_frontend; addConsoleMessage(adoptPtr(new ConsoleMessage(canGenerateCallStack, source, type, level, message, scriptId, lineNumber, columnNumber, state, requestIdentifier))); }
// --------------------------------------------------------------------- void selNextSpecifiedBuilding(STRUCTURE_TYPE structType) { STRUCTURE *psResult = nullptr, *psOldStruct = nullptr, *psFirst = nullptr; bool bLaterInList = false; /* Firstly, start coughing if the type is invalid */ ASSERT(structType <= NUM_DIFF_BUILDINGS, "Invalid structure type %u", structType); for (STRUCTURE *psCurr = apsStructLists[selectedPlayer]; psCurr && !psResult; psCurr = psCurr->psNext) { if ((psCurr->pStructureType->type == structType) && (psCurr->status == SS_BUILT)) { if (!psFirst) { psFirst = psCurr; } if (psCurr->selected) { bLaterInList = true; psOldStruct = psCurr; } else if (bLaterInList) { psResult = psCurr; } } } if (!psResult && psFirst) { psResult = psFirst; } if (psResult && !psResult->died) { if (getWarCamStatus()) { camToggleStatus(); } setViewPos(map_coord(psResult->pos.x), map_coord(psResult->pos.y), false); if (psOldStruct) { psOldStruct->selected = false; } psResult->selected = true; triggerEventSelected(); jsDebugSelected(psResult); } else { // Can't find required building addConsoleMessage("Cannot find required building!", LEFT_JUSTIFY, SYSTEM_MESSAGE); } }
void InspectorConsoleAgent::didReceiveResponse(unsigned long identifier, const ResourceResponse& response) { if (!developerExtrasEnabled()) return; if (response.httpStatusCode() >= 400) { String message = "Failed to load resource: the server responded with a status of " + String::number(response.httpStatusCode()) + " (" + response.httpStatusText() + ')'; String requestId = IdentifiersFactory::requestId(identifier); addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, ErrorMessageLevel, message, response.url().string(), requestId))); } }
void printConsoleNameChange(const char *oldName, const char *newName) { char msg[MAX_CONSOLE_STRING_LENGTH]; // Player changed name. sstrcpy(msg, oldName); // Old name. sstrcat(msg, " → "); // Separator sstrcat(msg, newName); // New name. addConsoleMessage(msg, DEFAULT_JUSTIFY, selectedPlayer); // display }
// Write a message to the console. bool recvTextMessage(NETQUEUE queue) { UDWORD playerIndex; char msg[MAX_CONSOLE_STRING_LENGTH]; char newmsg[MAX_CONSOLE_STRING_LENGTH]; memset(msg, 0x0, sizeof(msg)); memset(newmsg, 0x0, sizeof(newmsg)); NETbeginDecode(queue, NET_TEXTMSG); // Who this msg is from NETuint32_t(&playerIndex); // The message to send NETstring(newmsg, MAX_CONSOLE_STRING_LENGTH); NETend(); if (whosResponsible(playerIndex) != queue.index) { playerIndex = queue.index; // Fix corrupted playerIndex. } if (playerIndex >= MAX_PLAYERS || (!NetPlay.players[playerIndex].allocated && NetPlay.players[playerIndex].ai == AI_OPEN)) { return false; } sstrcpy(msg, NetPlay.players[playerIndex].name); // Seperator sstrcat(msg, ": "); // Add message sstrcat(msg, newmsg); addConsoleMessage(msg, DEFAULT_JUSTIFY, playerIndex); // Multiplayer message callback // Received a console message from a player, save MultiMsgPlayerFrom = playerIndex; MultiMsgPlayerTo = selectedPlayer; sstrcpy(MultiplayMsg, newmsg); eventFireCallbackTrigger((TRIGGER_TYPE)CALL_AI_MSG); // make some noise! if (titleMode == MULTIOPTION || titleMode == MULTILIMIT) { audio_PlayTrack(FE_AUDIO_MESSAGEEND); } else if (!ingame.localJoiningInProgress) { audio_PlayTrack(ID_SOUND_MESSAGEEND); } return true; }
void InspectorConsoleAgent::didFailLoading(unsigned long identifier, const ResourceError& error) { if (!m_inspectorAgent->enabled()) return; if (error.isCancellation()) // Report failures only. return; String message = "Failed to load resource"; if (!error.localizedDescription().isEmpty()) message += ": " + error.localizedDescription(); addConsoleMessage(adoptPtr(new ConsoleMessage(OtherMessageSource, NetworkErrorMessageType, ErrorMessageLevel, message, error.failingURL(), identifier))); }
void InspectorConsoleAgent::addMessageToConsole(std::unique_ptr<ConsoleMessage> message) { if (!m_injectedScriptManager.inspectorEnvironment().developerExtrasEnabled()) return; if (message->type() == MessageType::Clear) { ErrorString unused; clearMessages(unused); } addConsoleMessage(WTFMove(message)); }
/** Play an intelligence message. * This function is used from scripts to give updates to the mission. */ void displayImmediateMessage(MESSAGE *psMessage) { /* This has to be changed to support a script calling a message in the intellegence screen */ psCurrentMsg = psMessage; StartMessageSequences(psMessage,true); // remind the player that the message can be seen again from // the intelligence screen addConsoleMessage(_("New Intelligence Report"), CENTRE_JUSTIFY, SYSTEM_MESSAGE); }
void InspectorConsoleAgent::didFailLoading(unsigned long identifier, const ResourceError& error) { if (!developerExtrasEnabled()) return; if (error.isCancellation()) // Report failures only. return; String message = "Failed to load resource"; if (!error.localizedDescription().isEmpty()) message += ": " + error.localizedDescription(); String requestId = IdentifiersFactory::requestId(identifier); addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, ErrorMessageLevel, message, error.failingURL(), requestId))); }
void InspectorConsoleAgent::resourceRetrievedByXMLHttpRequest(unsigned long identifier, const String& url, const String& sendURL, unsigned sendLineNumber) { if (!developerExtrasEnabled()) return; if (m_frontend && m_state->getBoolean(ConsoleAgentState::monitoringXHR)) { String message = "XHR finished loading: \"" + url + "\"."; String requestId = IdentifiersFactory::requestId(identifier); addConsoleMessage(adoptPtr(new ConsoleMessage(NetworkMessageSource, LogMessageType, LogMessageLevel, message, sendURL, sendLineNumber, requestId))); } }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, PassRefPtr<ScriptCallStack> callStack, unsigned long requestIdentifier) { if (!developerExtrasEnabled()) return; if (type == ClearMessageType) { ErrorString error; clearMessages(&error); } addConsoleMessage(adoptPtr(new ConsoleMessage(source, type, level, message, 0, callStack, requestIdentifier))); }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, const String& scriptId, unsigned lineNumber, unsigned long requestIdentifier) { if (!developerExtrasEnabled()) return; if (type == ClearMessageType) { ErrorString error; clearMessages(&error); } addConsoleMessage(adoptPtr(new ConsoleMessage(source, type, level, message, scriptId, lineNumber, requestIdentifier))); }
void InspectorConsoleAgent::addMessageToConsole(MessageSource source, MessageType type, MessageLevel level, const String& message, JSC::ExecState* state, PassRefPtr<ScriptArguments> arguments, unsigned long requestIdentifier) { if (!m_injectedScriptManager->inspectorEnvironment().developerExtrasEnabled()) return; if (type == MessageType::Clear) { ErrorString error; clearMessages(&error); } addConsoleMessage(adoptPtr(new ConsoleMessage(!isWorkerAgent(), source, type, level, message, arguments, state, requestIdentifier))); }