Add a command line flag --v8-proxy-resolver, to select the new PAC implementa...

chrome/browser/debugger/debugger_shell.cc

 // Copyright (c) 2006-2008 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 "chrome/browser/debugger/debugger_shell.h"
 
 #include "build/build_config.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
@@ skipping 17 matching lines @@
 #endif
 
 DebuggerShell::DebuggerShell(DebuggerInputOutput* io) : io_(io),
                                                         debugger_ready_(true) {
 }
 
 DebuggerShell::~DebuggerShell() {
   io_->Stop();
   io_ = NULL;
 
+  v8::Locker locked;
   v8::HandleScope scope;
   SubshellFunction("exit", 0, NULL);
   v8::V8::RemoveMessageListeners(&DelegateMessageListener);
   v8_this_.Dispose();
   v8_context_.Dispose();
   shell_.Dispose();
 }
 
 void DebuggerShell::Start() {
   io_->Start(this);
 
+  v8::Locker locked;
   v8::HandleScope scope;
 
   v8_this_ = v8::Persistent<v8::External>::New(v8::External::New(this));
 
   v8::V8::AddMessageListener(&DelegateMessageListener, v8_this_);
 
   v8::Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
 
   // shell function
   v8::Local<v8::FunctionTemplate> shell_template =
@@ skipping 127 matching lines @@
 }
 
 void DebuggerShell::DelegateMessageListener(v8::Handle<v8::Message> message,
                                     v8::Handle<v8::Value> data) {
   DCHECK(!data.IsEmpty());
   DebuggerShell* debugger =
     static_cast<DebuggerShell*>(v8::External::Cast(*data)->Value());
   debugger->MessageListener(message);
 }
 
 void DebuggerShell::MessageListener(v8::Handle<v8::Message> message) {

[Erik does not do reviews, 2009/03/03 17:20:09]

Since there can only be one message listener, I assume we need to do something
different here.

   v8::HandleScope scope;
   v8::Local<v8::String> msg_str = message->Get();
   PrintObject(msg_str);
 
   v8::Handle<v8::Value> data = message->GetScriptResourceName();
   if (!data.IsEmpty() && !data->IsUndefined()) {
     std::wstring out;
     ObjectToString(data, &out);
     int line_number = message->GetLineNumber();
     if (line_number >= 0)
       out += StringPrintf(L":%d", line_number);
     PrintLine(out);
     data = message->GetSourceLine();
     if (!data->IsUndefined()) {
       ObjectToString(data, &out);
       PrintLine(out);
     }
   }
 }
 
 void DebuggerShell::Debug(TabContents* tab) {
+  v8::Locker locked;
   v8::HandleScope outer;
   v8::Context::Scope scope(v8_context_);
 
   v8::Local<v8::Object> global = v8_context_->Global();
   v8::Local<v8::Value> function = global->Get(v8::String::New("debug"));
   if (function->IsFunction()) {
     TabNode* node = new TabNode(tab);
     v8::Handle<v8::Value> argv[] = {node->NewInstance()};
     PrintObject(v8::Function::Cast(*function)->Call(global, 1, argv));
   }
 }
 
 void DebuggerShell::DebugMessage(const std::wstring& msg) {
+  v8::Locker locked;
   v8::HandleScope scope;
 
   if (msg.length()) {
     if ((msg[0] == L'{' || msg[0] == L'[' || msg[0] == L'(') && (!shell_.IsEmpty())) {
       // v8's wide String constructor requires uint16 rather than wchar
       const uint16* data = reinterpret_cast<const uint16* >(msg.c_str());
       v8::Handle<v8::Value> argv[] = {v8::String::New(data)};
       PrintObject(SubshellFunction("response", 1, argv));
       PrintPrompt();
     } else {
       if (msg[msg.length() - 1] == L'\n')
         PrintString(msg);
       else
         PrintLine(msg);
     }
   }
 }
 
 void DebuggerShell::OnDebugAttach() {
+  v8::Locker locked;
   v8::HandleScope scope;
   SubshellFunction("on_attach", 0, NULL);
 }
 
 void DebuggerShell::OnDebugDisconnect() {
+  v8::Locker locked;
   v8::HandleScope scope;
   SubshellFunction("on_disconnect", 0, NULL);
 }
 
 void DebuggerShell::ObjectToString(v8::Handle<v8::Value> result, std::wstring* str) {
   v8::HandleScope scope;
   if (!result.IsEmpty() && !result->IsUndefined()) {
     v8::Local<v8::String> str_obj = result->ToString();
     if (!str_obj.IsEmpty()) {
       int length = str_obj->Length();
@@ skipping 51 matching lines @@
 void DebuggerShell::PrintLine(const std::string& out) {
   if (io_)
     io_->OutputLine(out);
 }
 
 void DebuggerShell::PrintPrompt() {
   std::wstring out = L"Chrome> ";
   if (!shell_.IsEmpty()) {
     if (!debugger_ready_)
       return;
+    v8::Locker locked;
     v8::HandleScope outer;
     v8::Handle<v8::Value> result = CompileAndRun("shell_.prompt()");
     if (!result.IsEmpty() && !result->IsUndefined()) {
       ObjectToString(result, &out);
     }
   }
   if (io_)
     io_->OutputPrompt(out);
 }
 
 void DebuggerShell::ProcessCommand(const std::wstring& data) {
+  v8::Locker locked;
   v8::HandleScope outer;
   v8::Context::Scope scope(v8_context_);
   if (!shell_.IsEmpty() && data.substr(0, 7) != L"source(") {
     if (data == L"exit") {
       PrintObject(SubshellFunction("exit", 0, NULL));
       v8_context_->Global()->Delete(v8::String::New("shell_"));
       shell_.Dispose();
       shell_.Clear();
     } else {
       const uint16* utf16 = reinterpret_cast<const uint16*>(data.c_str());
@@ skipping 21 matching lines @@
 }
 
 void DebuggerShell::LoadUserConfig() {
   std::wstring path;
   PathService::Get(chrome::DIR_USER_DATA, &path);
   file_util::AppendToPath(&path, L"debugger_custom.js");
   LoadFile(path);
 }
 
 void DebuggerShell::DidConnect() {
+  v8::Locker locked;
   v8::HandleScope outer;
   v8::Context::Scope scope(v8_context_);
 
   LoadUserConfig();
 
   PrintPrompt();
 }
 
 void DebuggerShell::DidDisconnect() {
+  v8::Locker locked;
   v8::HandleScope outer;
   SubshellFunction("exit", 0, NULL);
 }
 
 v8::Handle<v8::Value> DebuggerShell::CompileAndRun(
     const std::string& str,
     const std::string& filename) {
   const std::wstring wstr = UTF8ToWide(str);
   return CompileAndRun(wstr, filename);
 }
 
 v8::Handle<v8::Value> DebuggerShell::CompileAndRun(
     const std::wstring& wstr,
     const std::string& filename) {
+  v8::Locker locked;
   v8::Context::Scope scope(v8_context_);
   v8::Handle<v8::String> scriptname;
   if (filename.length() > 0) {
     scriptname = v8::String::New(filename.c_str());
   } else {
     scriptname = v8::String::New("");
   }
   const uint16* utf16 = reinterpret_cast<const uint16*>(wstr.c_str());
   v8::ScriptOrigin origin = v8::ScriptOrigin(scriptname);
   v8::Local<v8::Script> code =
       v8::Script::Compile(v8::String::New(utf16), &origin);
   if (!code.IsEmpty()) {
     v8::Local<v8::Value> result = code->Run();
     if (!result.IsEmpty()) {
       return result;
     }
   }
   return v8::Undefined();
 }