NO CODE CHANGE.

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 67 matching lines @@
   ChromeNode* chrome = new ChromeNode(this);
   v8_context_->Global()->Set(v8::String::New("chrome"),
                              chrome->NewInstance());
 
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   const std::string& debugger_shell_js =
       rb.GetDataResource(IDR_DEBUGGER_SHELL_JS);
   CompileAndRun(debugger_shell_js, "chrome.dll/debugger_shell.js");
 }
 
-void DebuggerShell::HandleWeakReference(v8::Persistent<v8::Value> obj, void* data) {
+void DebuggerShell::HandleWeakReference(v8::Persistent<v8::Value> obj,
+                                        void* data) {
   DebuggerNodeWrapper* node = static_cast<DebuggerNodeWrapper*>(data);
   node->Release();
 }
 
 v8::Handle<v8::Value> DebuggerShell::SetDebuggerReady(const v8::Arguments& args,
                                                       DebuggerShell* debugger) {
   if (args[0]->IsBoolean()) {
     bool flag = args[0]->BooleanValue();
     debugger->debugger_ready_ = flag;
     debugger->GetIo()->SetDebuggerReady(flag);
   }
   return v8::Undefined();
 }
 
 v8::Handle<v8::Value> DebuggerShell::SetDebuggerBreak(const v8::Arguments& args,
                                                       DebuggerShell* debugger) {
   if (args[0]->IsBoolean()) {
     bool flag = args[0]->BooleanValue();
     debugger->GetIo()->SetDebuggerBreak(flag);
   }
   return v8::Undefined();
 }
 
 DebuggerInputOutput* DebuggerShell::GetIo() {
   return io_.get();
 }
 
-v8::Handle<v8::Value> DebuggerShell::DelegateSubshell(const v8::Arguments& args) {
+v8::Handle<v8::Value> DebuggerShell::DelegateSubshell(
+    const v8::Arguments& args) {
   DebuggerShell* debugger =
     static_cast<DebuggerShell*>(v8::External::Cast(*args.Data())->Value());
   return debugger->Subshell(args);
 }
 
 v8::Handle<v8::Value> DebuggerShell::Subshell(const v8::Arguments& args) {
   if (args.Length() != 1) {
     return v8::Undefined();
   }
   if (!shell_.IsEmpty()) {
     shell_.Dispose();
     shell_.Clear();
     v8_context_->Global()->Delete(v8::String::New("shell_"));
   }
   if (args[0]->IsFunction()) {
     v8::Handle<v8::Function> func = v8::Handle<v8::Function>::Cast(args[0]);
     v8::Local<v8::Object> obj = func->NewInstance();
     if (!obj->IsUndefined()) {
       shell_ = v8::Persistent<v8::Object>::New(obj);
       v8_context_->Global()->Set(v8::String::New("shell_"), shell_);
     }
   } else if (args[0]->IsObject()) {
-    shell_ = v8::Persistent<v8::Object>::New(v8::Local<v8::Object>::Cast(args[0]));
+    shell_ =
+        v8::Persistent<v8::Object>::New(v8::Local<v8::Object>::Cast(args[0]));
     v8_context_->Global()->Set(v8::String::New("shell_"), shell_);
   }
   return v8::Undefined();
 }
 
 v8::Handle<v8::Value> DebuggerShell::SubshellFunction(const char* func,
                                               int argc,
                                               v8::Handle<v8::Value>* argv) {
   if (!shell_.IsEmpty()) {
     v8::Context::Scope scope(v8_context_);
@@ skipping 78 matching lines @@
     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())) {
+    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) {
+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();
       wchar_t* buf = new wchar_t[length + 1];
       int size = str_obj->Write(reinterpret_cast<uint16_t*>(buf));
       str->clear();
       str->append(buf, size);
       delete[] buf;
     }
   }
 }
 
-void DebuggerShell::ObjectToString(v8::Handle<v8::Value> result, std::string* str) {
+void DebuggerShell::ObjectToString(v8::Handle<v8::Value> result,
+                                   std::string* 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();
       char* buf = new char[length + 1];
       str_obj->WriteAscii(buf);
       str->clear();
       str->append(buf);
       delete[] buf;
@@ skipping 130 matching lines @@
   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();
 }