NO CODE CHANGE.

chrome/browser/debugger/debugger_node.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_node.h"
 
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
@@ skipping 51 matching lines @@
   v8::Local<v8::External> node = v8::External::New(wrap);
   // TODO(erikkay): cache these templates?
   v8::Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New();
   if (IsFunction()) {
     templ->SetCallHandler(&DebuggerNode::NodeFunc, node);
     v8::Local<v8::Function> f = templ->GetFunction();
     return f;
   }
   v8::Local<v8::ObjectTemplate> instance = templ->InstanceTemplate();
   if (IsObject()) {
-    instance->SetNamedPropertyHandler(&DebuggerNode::NodeGetter, 0, 0, 0, 0, node);
+    instance->SetNamedPropertyHandler(&DebuggerNode::NodeGetter, 0, 0, 0, 0,
+                                      node);
     // TODO(erikkay): verify that the interceptor does not have to be
     // behind the object
   }
   if (IsCollection()) {
-    instance->SetIndexedPropertyHandler(&DebuggerNode::NodeIndex, 0, 0, 0, 0, node);
+    instance->SetIndexedPropertyHandler(&DebuggerNode::NodeIndex, 0, 0, 0, 0,
+                                        node);
   }
   v8::Local<v8::Object> ret = instance->NewInstance();
   v8::Persistent<v8::Object> p = v8::Persistent<v8::Object>::New(ret);
   p.MakeWeak(wrap, &DebuggerShell::HandleWeakReference);
   return ret;
 }
 
 v8::Handle<v8::Value> DebuggerNode::NodeGetter(v8::Local<v8::String> prop,
                                             const v8::AccessorInfo& info) {
-  DebuggerNodeWrapper* w =
-    static_cast<DebuggerNodeWrapper*>(v8::External::Cast(*info.Data())->Value());
+  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
+        *info.Data())->Value());
   DebuggerNode* n = w->node();
   if (n->IsValid() && n->IsObject()) {
     return n->PropGetter(prop, info);
   } else {
     return v8::Undefined();
   }
 }
 
 v8::Handle<v8::Value> DebuggerNode::NodeIndex(uint32_t index,
                                            const v8::AccessorInfo& info) {
-  DebuggerNodeWrapper* w =
-    static_cast<DebuggerNodeWrapper*>(v8::External::Cast(*info.Data())->Value());
+  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
+      *info.Data())->Value());
   DebuggerNode* n = w->node();
   if (n->IsValid() && n->IsCollection()) {
     return n->IndexGetter(index, info);
   } else {
     return v8::Undefined();
   }
 }
 
 v8::Handle<v8::Value> DebuggerNode::NodeFunc(const v8::Arguments& args) {
-  DebuggerNodeWrapper* w =
-    static_cast<DebuggerNodeWrapper*>(v8::External::Cast(*args.Data())->Value());
+  DebuggerNodeWrapper* w = static_cast<DebuggerNodeWrapper*>(v8::External::Cast(
+      *args.Data())->Value());
   DebuggerNode* n = w->node();
   if (n->IsValid() && n->IsFunction()) {
     return n->Function(args);
   } else {
     return v8::Undefined();
   }
 }
 
 
 
 /////////////////////////////////////////////
 
 ChromeNode::ChromeNode(DebuggerShell* debugger) {
   debugger_ = debugger;
 }
 
 ChromeNode::~ChromeNode() {
 }
 
 v8::Handle<v8::Value> ChromeNode::PropGetter(v8::Handle<v8::String> prop,
                                              const v8::AccessorInfo& info) {
   if (prop->Equals(v8::String::New("pid"))) {
     return v8::Number::New(base::GetCurrentProcId());
   } else if (prop->Equals(v8::String::New("browser"))) {
     BrowserListNode *node = BrowserListNode::BrowserList();
     return node->NewInstance();
   } else if (prop->Equals(v8::String::New("setDebuggerReady"))) {
     FunctionNode<DebuggerShell>* f =
-      new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerReady, debugger_);
+      new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerReady,
+                                      debugger_);
     return f->NewInstance();
   } else if (prop->Equals(v8::String::New("setDebuggerBreak"))) {
     FunctionNode<DebuggerShell>* f =
-      new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerBreak, debugger_);
+      new FunctionNode<DebuggerShell>(DebuggerShell::SetDebuggerBreak,
+                                      debugger_);
     return f->NewInstance();
   } else if (prop->Equals(v8::String::New("foo"))) {
     return v8::Undefined();
   } else {
     return prop;
   }
 }
 
 void ChromeNode::StopObserving(NotificationService *service) {
 }
@@ skipping 231 matching lines @@
 }
 
 
 //////////////////////////////////
 
 template<class T>
 v8::Handle<v8::Value> FunctionNode<T>::Function(const v8::Arguments &args) {
   return function_(args, data_);
 }