| // Copyright 2014 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 "extensions/renderer/messaging_bindings.h" |
| |
| #include <stdint.h> |
| |
| #include <map> |
| #include <string> |
| |
| #include "base/bind.h" |
| #include "base/bind_helpers.h" |
| #include "base/callback.h" |
| #include "base/callback_helpers.h" |
| #include "base/lazy_instance.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/metrics/histogram_macros.h" |
| #include "base/values.h" |
| #include "content/public/child/v8_value_converter.h" |
| #include "content/public/common/child_process_host.h" |
| #include "content/public/renderer/render_frame.h" |
| #include "content/public/renderer/render_thread.h" |
| #include "extensions/common/api/messaging/message.h" |
| #include "extensions/common/extension_messages.h" |
| #include "extensions/common/manifest_handlers/externally_connectable.h" |
| #include "extensions/renderer/extension_frame_helper.h" |
| #include "extensions/renderer/extension_port.h" |
| #include "extensions/renderer/gc_callback.h" |
| #include "extensions/renderer/script_context.h" |
| #include "extensions/renderer/script_context_set.h" |
| #include "extensions/renderer/v8_helpers.h" |
| #include "third_party/WebKit/public/web/WebDocument.h" |
| #include "third_party/WebKit/public/web/WebLocalFrame.h" |
| #include "third_party/WebKit/public/web/WebScopedUserGesture.h" |
| #include "third_party/WebKit/public/web/WebScopedWindowFocusAllowedIndicator.h" |
| #include "third_party/WebKit/public/web/WebUserGestureIndicator.h" |
| #include "v8/include/v8.h" |
| |
| // Message passing API example (in a content script): |
| // var port = runtime.connect(); |
| // port.postMessage('Can you hear me now?'); |
| // port.onmessage.addListener(function(msg, port) { |
| // alert('response=' + msg); |
| // port.postMessage('I got your reponse'); |
| // }); |
| |
| namespace extensions { |
| |
| using v8_helpers::ToV8String; |
| |
| namespace { |
| |
| // A global map between ScriptContext and MessagingBindings. |
| base::LazyInstance<std::map<ScriptContext*, MessagingBindings*>> |
| g_messaging_map = LAZY_INSTANCE_INITIALIZER; |
| |
| void HasMessagePort(int global_port_id, |
| bool* has_port, |
| ScriptContext* script_context) { |
| if (*has_port) |
| return; // Stop checking if the port was found. |
| |
| MessagingBindings* bindings = g_messaging_map.Get()[script_context]; |
| DCHECK(bindings); |
| if (bindings->GetPortWithGlobalId(global_port_id)) |
| *has_port = true; |
| } |
| |
| void DispatchOnConnectToScriptContext( |
| int global_target_port_id, |
| const std::string& channel_name, |
| const ExtensionMsg_TabConnectionInfo* source, |
| const ExtensionMsg_ExternalConnectionInfo& info, |
| const std::string& tls_channel_id, |
| bool* port_created, |
| ScriptContext* script_context) { |
| MessagingBindings* bindings = g_messaging_map.Get()[script_context]; |
| DCHECK(bindings); |
| |
| int opposite_port_id = global_target_port_id ^ 1; |
| if (bindings->GetPortWithGlobalId(opposite_port_id)) |
| return; // The channel was opened by this same context; ignore it. |
| |
| ExtensionPort* port = |
| bindings->CreateNewPortWithGlobalId(global_target_port_id); |
| int local_port_id = port->local_id(); |
| // Remove the port. |
| base::ScopedClosureRunner remove_port( |
| base::Bind(&MessagingBindings::RemovePortWithLocalId, |
| bindings->GetWeakPtr(), local_port_id)); |
| |
| v8::Isolate* isolate = script_context->isolate(); |
| v8::HandleScope handle_scope(isolate); |
| |
| |
| const std::string& source_url_spec = info.source_url.spec(); |
| std::string target_extension_id = script_context->GetExtensionID(); |
| const Extension* extension = script_context->extension(); |
| |
| v8::Local<v8::Value> tab = v8::Null(isolate); |
| v8::Local<v8::Value> tls_channel_id_value = v8::Undefined(isolate); |
| v8::Local<v8::Value> guest_process_id = v8::Undefined(isolate); |
| v8::Local<v8::Value> guest_render_frame_routing_id = v8::Undefined(isolate); |
| |
| if (extension) { |
| if (!source->tab.empty() && !extension->is_platform_app()) { |
| std::unique_ptr<content::V8ValueConverter> converter( |
| content::V8ValueConverter::create()); |
| tab = converter->ToV8Value(&source->tab, script_context->v8_context()); |
| } |
| |
| ExternallyConnectableInfo* externally_connectable = |
| ExternallyConnectableInfo::Get(extension); |
| if (externally_connectable && |
| externally_connectable->accepts_tls_channel_id) { |
| v8::Local<v8::String> v8_tls_channel_id; |
| if (ToV8String(isolate, tls_channel_id.c_str(), &v8_tls_channel_id)) |
| tls_channel_id_value = v8_tls_channel_id; |
| } |
| |
| if (info.guest_process_id != content::ChildProcessHost::kInvalidUniqueID) { |
| guest_process_id = v8::Integer::New(isolate, info.guest_process_id); |
| guest_render_frame_routing_id = |
| v8::Integer::New(isolate, info.guest_render_frame_routing_id); |
| } |
| } |
| |
| v8::Local<v8::String> v8_channel_name; |
| v8::Local<v8::String> v8_source_id; |
| v8::Local<v8::String> v8_target_extension_id; |
| v8::Local<v8::String> v8_source_url_spec; |
| if (!ToV8String(isolate, channel_name.c_str(), &v8_channel_name) || |
| !ToV8String(isolate, info.source_id.c_str(), &v8_source_id) || |
| !ToV8String(isolate, target_extension_id.c_str(), |
| &v8_target_extension_id) || |
| !ToV8String(isolate, source_url_spec.c_str(), &v8_source_url_spec)) { |
| NOTREACHED() << "dispatchOnConnect() passed non-string argument"; |
| return; |
| } |
| |
| v8::Local<v8::Value> arguments[] = { |
| // portId |
| v8::Integer::New(isolate, local_port_id), |
| // channelName |
| v8_channel_name, |
| // sourceTab |
| tab, |
| // source_frame_id |
| v8::Integer::New(isolate, source->frame_id), |
| // guestProcessId |
| guest_process_id, |
| // guestRenderFrameRoutingId |
| guest_render_frame_routing_id, |
| // sourceExtensionId |
| v8_source_id, |
| // targetExtensionId |
| v8_target_extension_id, |
| // sourceUrl |
| v8_source_url_spec, |
| // tlsChannelId |
| tls_channel_id_value, |
| }; |
| |
| v8::Local<v8::Value> retval = |
| script_context->module_system()->CallModuleMethod( |
| "messaging", "dispatchOnConnect", arraysize(arguments), arguments); |
| |
| if (!retval.IsEmpty() && !retval->IsUndefined()) { |
| CHECK(retval->IsBoolean()); |
| bool used = retval.As<v8::Boolean>()->Value(); |
| *port_created |= used; |
| if (used) // Port was used; don't remove it. |
| remove_port.ReplaceClosure(base::Closure()); |
| } else { |
| LOG(ERROR) << "Empty return value from dispatchOnConnect."; |
| } |
| } |
| |
| void DeliverMessageToScriptContext(const Message& message, |
| int global_target_port_id, |
| ScriptContext* script_context) { |
| MessagingBindings* bindings = g_messaging_map.Get()[script_context]; |
| DCHECK(bindings); |
| ExtensionPort* port = bindings->GetPortWithGlobalId(global_target_port_id); |
| if (!port) |
| return; |
| |
| v8::Isolate* isolate = script_context->isolate(); |
| v8::HandleScope handle_scope(isolate); |
| |
| v8::Local<v8::Value> port_id_handle = |
| v8::Integer::New(isolate, port->local_id()); |
| |
| v8::Local<v8::String> v8_data; |
| if (!ToV8String(isolate, message.data.c_str(), &v8_data)) |
| return; |
| std::vector<v8::Local<v8::Value>> arguments; |
| arguments.push_back(v8_data); |
| arguments.push_back(port_id_handle); |
| |
| std::unique_ptr<blink::WebScopedUserGesture> web_user_gesture; |
| std::unique_ptr<blink::WebScopedWindowFocusAllowedIndicator> |
| allow_window_focus; |
| if (message.user_gesture) { |
| web_user_gesture.reset( |
| new blink::WebScopedUserGesture(script_context->web_frame())); |
| |
| if (script_context->web_frame()) { |
| blink::WebDocument document = script_context->web_frame()->document(); |
| allow_window_focus.reset(new blink::WebScopedWindowFocusAllowedIndicator( |
| &document)); |
| } |
| } |
| |
| script_context->module_system()->CallModuleMethodSafe( |
| "messaging", "dispatchOnMessage", &arguments); |
| } |
| |
| void DispatchOnDisconnectToScriptContext(int global_port_id, |
| const std::string& error_message, |
| ScriptContext* script_context) { |
| MessagingBindings* bindings = g_messaging_map.Get()[script_context]; |
| DCHECK(bindings); |
| ExtensionPort* port = bindings->GetPortWithGlobalId(global_port_id); |
| if (!port) |
| return; |
| |
| v8::Isolate* isolate = script_context->isolate(); |
| v8::HandleScope handle_scope(isolate); |
| |
| std::vector<v8::Local<v8::Value>> arguments; |
| arguments.push_back(v8::Integer::New(isolate, port->local_id())); |
| v8::Local<v8::String> v8_error_message; |
| if (!error_message.empty()) |
| ToV8String(isolate, error_message.c_str(), &v8_error_message); |
| if (!v8_error_message.IsEmpty()) { |
| arguments.push_back(v8_error_message); |
| } else { |
| arguments.push_back(v8::Null(isolate)); |
| } |
| |
| script_context->module_system()->CallModuleMethodSafe( |
| "messaging", "dispatchOnDisconnect", &arguments); |
| } |
| |
| } // namespace |
| |
| MessagingBindings::MessagingBindings(ScriptContext* context) |
| : ObjectBackedNativeHandler(context), weak_ptr_factory_(this) { |
| g_messaging_map.Get()[context] = this; |
| RouteFunction("CloseChannel", base::Bind(&MessagingBindings::CloseChannel, |
| base::Unretained(this))); |
| RouteFunction("PostMessage", base::Bind(&MessagingBindings::PostMessage, |
| base::Unretained(this))); |
| // TODO(fsamuel, kalman): Move BindToGC out of messaging natives. |
| RouteFunction("BindToGC", base::Bind(&MessagingBindings::BindToGC, |
| base::Unretained(this))); |
| RouteFunction("OpenChannelToExtension", "runtime.connect", |
| base::Bind(&MessagingBindings::OpenChannelToExtension, |
| base::Unretained(this))); |
| RouteFunction("OpenChannelToNativeApp", "runtime.connectNative", |
| base::Bind(&MessagingBindings::OpenChannelToNativeApp, |
| base::Unretained(this))); |
| RouteFunction( |
| "OpenChannelToTab", |
| base::Bind(&MessagingBindings::OpenChannelToTab, base::Unretained(this))); |
| } |
| |
| MessagingBindings::~MessagingBindings() { |
| g_messaging_map.Get().erase(context()); |
| if (ports_created_normal_ > 0 || ports_created_in_before_unload_ > 0 || |
| ports_created_in_unload_ > 0) { |
| UMA_HISTOGRAM_COUNTS_1000( |
| "Extensions.Messaging.ExtensionPortsCreated.InBeforeUnload", |
| ports_created_in_before_unload_); |
| UMA_HISTOGRAM_COUNTS_1000( |
| "Extensions.Messaging.ExtensionPortsCreated.InUnload", |
| ports_created_in_unload_); |
| UMA_HISTOGRAM_COUNTS_1000( |
| "Extensions.Messaging.ExtensionPortsCreated.Normal", |
| ports_created_normal_); |
| } |
| } |
| |
| // static |
| void MessagingBindings::ValidateMessagePort( |
| const ScriptContextSet& context_set, |
| int global_port_id, |
| content::RenderFrame* render_frame) { |
| int routing_id = render_frame->GetRoutingID(); |
| |
| bool has_port = false; |
| context_set.ForEach(render_frame, |
| base::Bind(&HasMessagePort, global_port_id, &has_port)); |
| |
| // A reply is only sent if the port is missing, because the port is assumed to |
| // exist unless stated otherwise. |
| if (!has_port) { |
| content::RenderThread::Get()->Send( |
| new ExtensionHostMsg_CloseMessagePort(routing_id, |
| global_port_id, false)); |
| } |
| } |
| |
| // static |
| void MessagingBindings::DispatchOnConnect( |
| const ScriptContextSet& context_set, |
| int target_port_id, |
| const std::string& channel_name, |
| const ExtensionMsg_TabConnectionInfo& source, |
| const ExtensionMsg_ExternalConnectionInfo& info, |
| const std::string& tls_channel_id, |
| content::RenderFrame* restrict_to_render_frame) { |
| int routing_id = restrict_to_render_frame |
| ? restrict_to_render_frame->GetRoutingID() |
| : MSG_ROUTING_NONE; |
| bool port_created = false; |
| context_set.ForEach( |
| info.target_id, restrict_to_render_frame, |
| base::Bind(&DispatchOnConnectToScriptContext, target_port_id, |
| channel_name, &source, info, tls_channel_id, &port_created)); |
| // Note: |restrict_to_render_frame| may have been deleted at this point! |
| |
| if (port_created) { |
| content::RenderThread::Get()->Send( |
| new ExtensionHostMsg_OpenMessagePort(routing_id, target_port_id)); |
| } else { |
| content::RenderThread::Get()->Send(new ExtensionHostMsg_CloseMessagePort( |
| routing_id, target_port_id, false)); |
| } |
| } |
| |
| // static |
| void MessagingBindings::DeliverMessage( |
| const ScriptContextSet& context_set, |
| int target_port_id, |
| const Message& message, |
| content::RenderFrame* restrict_to_render_frame) { |
| context_set.ForEach( |
| restrict_to_render_frame, |
| base::Bind(&DeliverMessageToScriptContext, message, target_port_id)); |
| } |
| |
| // static |
| void MessagingBindings::DispatchOnDisconnect( |
| const ScriptContextSet& context_set, |
| int port_id, |
| const std::string& error_message, |
| content::RenderFrame* restrict_to_render_frame) { |
| context_set.ForEach( |
| restrict_to_render_frame, |
| base::Bind(&DispatchOnDisconnectToScriptContext, port_id, error_message)); |
| } |
| |
| ExtensionPort* MessagingBindings::GetPortWithGlobalId(int id) { |
| for (const auto& key_value : ports_) { |
| if (key_value.second->global_id() == id) |
| return key_value.second.get(); |
| } |
| return nullptr; |
| } |
| |
| ExtensionPort* MessagingBindings::CreateNewPortWithGlobalId(int global_id) { |
| int local_id = GetNextLocalId(); |
| ExtensionPort* port = |
| ports_ |
| .insert(std::make_pair( |
| local_id, base::MakeUnique<ExtensionPort>(context(), local_id))) |
| .first->second.get(); |
| port->SetGlobalId(global_id); |
| return port; |
| } |
| |
| void MessagingBindings::RemovePortWithLocalId(int local_id) { |
| ports_.erase(local_id); |
| } |
| |
| base::WeakPtr<MessagingBindings> MessagingBindings::GetWeakPtr() { |
| return weak_ptr_factory_.GetWeakPtr(); |
| } |
| |
| void MessagingBindings::PostMessage( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| // Arguments are (int32_t port_id, string message). |
| CHECK(args.Length() == 2); |
| CHECK(args[0]->IsInt32()); |
| CHECK(args[1]->IsString()); |
| |
| int port_id = args[0].As<v8::Int32>()->Value(); |
| auto iter = ports_.find(port_id); |
| if (iter != ports_.end()) { |
| iter->second->PostExtensionMessage(base::MakeUnique<Message>( |
| *v8::String::Utf8Value(args[1]), |
| blink::WebUserGestureIndicator::isProcessingUserGesture())); |
| } |
| } |
| |
| void MessagingBindings::CloseChannel( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| // Arguments are (int32_t port_id, bool force_close). |
| CHECK_EQ(2, args.Length()); |
| CHECK(args[0]->IsInt32()); |
| CHECK(args[1]->IsBoolean()); |
| |
| int port_id = args[0].As<v8::Int32>()->Value(); |
| bool force_close = args[1].As<v8::Boolean>()->Value(); |
| ClosePort(port_id, force_close); |
| } |
| |
| void MessagingBindings::BindToGC( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| CHECK(args.Length() == 3); |
| CHECK(args[0]->IsObject()); |
| CHECK(args[1]->IsFunction()); |
| CHECK(args[2]->IsInt32()); |
| int local_port_id = args[2].As<v8::Int32>()->Value(); |
| base::Closure fallback = base::Bind(&base::DoNothing); |
| if (local_port_id >= 0) { |
| // TODO(robwu): Falling back to closing the port shouldn't be needed. If |
| // the script context is destroyed, then the frame has navigated. But that |
| // is already detected by the browser, so this logic is redundant. Remove |
| // this fallback (and move BindToGC out of messaging because it is also |
| // used in other places that have nothing to do with messaging...). |
| fallback = base::Bind(&MessagingBindings::ClosePort, |
| weak_ptr_factory_.GetWeakPtr(), local_port_id, |
| false /* force_close */); |
| } |
| // Destroys itself when the object is GC'd or context is invalidated. |
| new GCCallback(context(), args[0].As<v8::Object>(), |
| args[1].As<v8::Function>(), fallback); |
| } |
| |
| void MessagingBindings::OpenChannelToExtension( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| content::RenderFrame* render_frame = context()->GetRenderFrame(); |
| if (!render_frame) |
| return; |
| |
| // The Javascript code should validate/fill the arguments. |
| CHECK_EQ(args.Length(), 3); |
| CHECK(args[0]->IsString()); |
| CHECK(args[1]->IsString()); |
| CHECK(args[2]->IsBoolean()); |
| |
| int local_id = GetNextLocalId(); |
| ports_[local_id] = base::MakeUnique<ExtensionPort>(context(), local_id); |
| |
| ExtensionMsg_ExternalConnectionInfo info; |
| // For messaging APIs, hosted apps should be considered a web page so hide |
| // its extension ID. |
| const Extension* extension = context()->extension(); |
| if (extension && !extension->is_hosted_app()) |
| info.source_id = extension->id(); |
| |
| info.target_id = *v8::String::Utf8Value(args[0]); |
| info.source_url = context()->url(); |
| std::string channel_name = *v8::String::Utf8Value(args[1]); |
| // TODO(devlin): Why is this not part of info? |
| bool include_tls_channel_id = |
| args.Length() > 2 ? args[2]->BooleanValue() : false; |
| |
| ExtensionFrameHelper* frame_helper = ExtensionFrameHelper::Get(render_frame); |
| DCHECK(frame_helper); |
| |
| blink::WebLocalFrame* web_frame = render_frame->GetWebFrame(); |
| // If the frame is unloading, we need to assign the port id synchronously to |
| // avoid dropping the message on the floor; see crbug.com/660706. |
| // TODO(devlin): Investigate whether we need to continue supporting this long- |
| // term, and, if so, find an alternative that doesn't require synchronous |
| // IPCs. |
| if (!web_frame->document().isNull() && |
| (web_frame->document().unloadStartedDoNotUse() || |
| web_frame->document().processingBeforeUnloadDoNotUse())) { |
| ports_created_in_before_unload_ += |
| web_frame->document().processingBeforeUnloadDoNotUse() ? 1 : 0; |
| ports_created_in_unload_ += |
| web_frame->document().unloadStartedDoNotUse() ? 1 : 0; |
| int global_id = frame_helper->RequestSyncPortId(info, channel_name, |
| include_tls_channel_id); |
| ports_[local_id]->SetGlobalId(global_id); |
| } else { |
| ++ports_created_normal_; |
| frame_helper->RequestPortId( |
| info, channel_name, include_tls_channel_id, |
| base::Bind(&MessagingBindings::SetGlobalPortId, |
| weak_ptr_factory_.GetWeakPtr(), local_id)); |
| } |
| |
| args.GetReturnValue().Set(static_cast<int32_t>(local_id)); |
| } |
| |
| void MessagingBindings::OpenChannelToNativeApp( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| // The Javascript code should validate/fill the arguments. |
| CHECK_EQ(args.Length(), 1); |
| CHECK(args[0]->IsString()); |
| // This should be checked by our function routing code. |
| CHECK(context()->GetAvailability("runtime.connectNative").is_available()); |
| |
| content::RenderFrame* render_frame = context()->GetRenderFrame(); |
| if (!render_frame) |
| return; |
| |
| std::string native_app_name = *v8::String::Utf8Value(args[0]); |
| |
| int local_id = GetNextLocalId(); |
| ports_[local_id] = base::MakeUnique<ExtensionPort>(context(), local_id); |
| |
| ExtensionFrameHelper* frame_helper = ExtensionFrameHelper::Get(render_frame); |
| DCHECK(frame_helper); |
| frame_helper->RequestNativeAppPortId( |
| native_app_name, |
| base::Bind(&MessagingBindings::SetGlobalPortId, |
| weak_ptr_factory_.GetWeakPtr(), local_id)); |
| args.GetReturnValue().Set(static_cast<int32_t>(local_id)); |
| } |
| |
| void MessagingBindings::OpenChannelToTab( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| content::RenderFrame* render_frame = context()->GetRenderFrame(); |
| if (!render_frame) |
| return; |
| |
| // tabs_custom_bindings.js unwraps arguments to tabs.connect/sendMessage and |
| // passes them to OpenChannelToTab, in the following order: |
| // - |tab_id| - Positive number that specifies the destination of the channel. |
| // - |frame_id| - Target frame(s) in the tab where onConnect is dispatched: |
| // -1 for all frames, 0 for the main frame, >0 for a child frame. |
| // - |extension_id| - ID of the initiating extension. |
| // - |channel_name| - A user-defined channel name. |
| CHECK(args.Length() == 4); |
| CHECK(args[0]->IsInt32()); |
| CHECK(args[1]->IsInt32()); |
| CHECK(args[2]->IsString()); |
| CHECK(args[3]->IsString()); |
| |
| int local_id = GetNextLocalId(); |
| ports_[local_id] = base::MakeUnique<ExtensionPort>(context(), local_id); |
| |
| ExtensionMsg_TabTargetConnectionInfo info; |
| info.tab_id = args[0]->Int32Value(); |
| info.frame_id = args[1]->Int32Value(); |
| // TODO(devlin): Why is this not part of info? |
| std::string extension_id = *v8::String::Utf8Value(args[2]); |
| std::string channel_name = *v8::String::Utf8Value(args[3]); |
| |
| ExtensionFrameHelper* frame_helper = ExtensionFrameHelper::Get(render_frame); |
| DCHECK(frame_helper); |
| frame_helper->RequestTabPortId( |
| info, extension_id, channel_name, |
| base::Bind(&MessagingBindings::SetGlobalPortId, |
| weak_ptr_factory_.GetWeakPtr(), local_id)); |
| |
| args.GetReturnValue().Set(static_cast<int32_t>(local_id)); |
| } |
| |
| void MessagingBindings::ClosePort(int local_port_id, bool force_close) { |
| // TODO(robwu): Merge this logic with CloseChannel once the TODO in BindToGC |
| // has been addressed. |
| auto iter = ports_.find(local_port_id); |
| if (iter != ports_.end()) { |
| std::unique_ptr<ExtensionPort> port = std::move(iter->second); |
| ports_.erase(iter); |
| port->Close(force_close); |
| // If the port hasn't been initialized, we can't delete it just yet, because |
| // we need to wait for it to send any pending messages. This is important |
| // to support the flow: |
| // var port = chrome.runtime.connect(); |
| // port.postMessage({message}); |
| // port.disconnect(); |
| if (!port->initialized()) |
| disconnected_ports_[port->local_id()] = std::move(port); |
| } |
| } |
| |
| void MessagingBindings::SetGlobalPortId(int local_id, int global_id) { |
| auto iter = ports_.find(local_id); |
| if (iter != ports_.end()) { |
| iter->second->SetGlobalId(global_id); |
| return; |
| } |
| |
| iter = disconnected_ports_.find(local_id); |
| DCHECK(iter != disconnected_ports_.end()); |
| iter->second->SetGlobalId(global_id); |
| // Setting the global id dispatches pending messages, so we can delete the |
| // port now. |
| disconnected_ports_.erase(iter); |
| } |
| |
| int MessagingBindings::GetNextLocalId() { return next_local_id_++; } |
| |
| } // namespace extensions |