[chrome.displaySource] Session notification improvements

extensions/renderer/display_source_custom_bindings.cc

 // Copyright 2015 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/display_source_custom_bindings.h"
 
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "content/public/child/v8_value_converter.h"
@@ skipping 53 matching lines @@
     }
   }
 
   return v8::Null(isolate);
 }
 
 }  // namespace
 
 void DisplaySourceCustomBindings::StartSession(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  CHECK_EQ(1, args.Length());
+  CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsObject());
+  CHECK(args[1]->IsFunction());
+
   v8::Isolate* isolate = context()->isolate();
   v8::Local<v8::Object> start_info = args[0].As<v8::Object>();
 
   v8::Local<v8::Value> sink_id_val =
       GetChildValue(start_info, "sinkId", isolate);
   CHECK(sink_id_val->IsInt32());
   const int sink_id = sink_id_val->ToInt32(isolate)->Value();
   if (GetDisplaySession(sink_id)) {
     isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
         isolate, kSessionAlreadyStarted)));
@@ skipping 71 matching lines @@
       weak_factory_.GetWeakPtr());
   auto on_terminated_callback = base::Bind(
       &DisplaySourceCustomBindings::OnSessionTerminated,
       weak_factory_.GetWeakPtr());
   auto on_error_callback = base::Bind(
       &DisplaySourceCustomBindings::OnSessionError,
       weak_factory_.GetWeakPtr());
   session->SetCallbacks(on_started_callback,
                         on_terminated_callback,
                         on_error_callback);
+
+  CallbackInfo cb_info = GetCallbackInfo(kStarted, sink_id);
+  args.GetReturnValue().Set(static_cast<int32_t>(cb_info.call_id));
+  callbacks_.push_back(cb_info);
+
   session->Start();
   session_map_.insert(std::make_pair(sink_id, std::move(session)));
 }
 
 void DisplaySourceCustomBindings::TerminateSession(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  CHECK_EQ(1, args.Length());
+  CHECK_EQ(2, args.Length());
   CHECK(args[0]->IsInt32());
+  CHECK(args[1]->IsFunction());
 
   v8::Isolate* isolate = context()->isolate();
   int sink_id = args[0]->ToInt32(args.GetIsolate())->Value();
   DisplaySourceSession* session = GetDisplaySession(sink_id);
   if (!session) {
     isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
         isolate, kSessionNotFound)));
     return;
   }
 
   if (session->state() == DisplaySourceSession::Terminating) {
     isolate->ThrowException(v8::Exception::Error(v8::String::NewFromUtf8(
         isolate, kSessionAlreadyTerminating)));
     return;
   }
+
+  CallbackInfo cb_info = GetCallbackInfo(kTerminated, sink_id);
+  args.GetReturnValue().Set(static_cast<int32_t>(cb_info.call_id));
+  callbacks_.push_back(cb_info);
+
   // The session will get removed from session_map_ in OnSessionTerminated.
   session->Terminate();
 }
 
-void DisplaySourceCustomBindings::DispatchSessionStarted(int sink_id) const {
+void DisplaySourceCustomBindings::CallCompletionCallback(
+    int sink_id,
+    CallbackType type,
+    const std::string& error_message) {
+  auto predicate = [sink_id, type](const CallbackInfo& info) -> bool {
+    return info.sink_id == sink_id && info.type == type;
+  };
+  auto it = std::find_if(callbacks_.begin(), callbacks_.end(), predicate);
+  if (it == callbacks_.end())
+    return;
+
   v8::Isolate* isolate = context()->isolate();
+  ModuleSystem* module_system = context()->module_system();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
-  v8::Local<v8::Array> event_args = v8::Array::New(isolate, 1);
-  event_args->Set(0, v8::Integer::New(isolate, sink_id));
-  context()->DispatchEvent("displaySource.onSessionStarted", event_args);
+
+  v8::Local<v8::Value> callback_args[2];
+  callback_args[0] = v8::Integer::New(isolate, it->call_id);
+  if (error_message.empty())
+    callback_args[1] = v8::Null(isolate);
+  else
+    callback_args[1] = v8::String::NewFromUtf8(isolate, error_message.c_str());
+
+  module_system->CallModuleMethod("displaySource", "callCompletionCallback", 2,
+                                  callback_args);
 }
 
 void DisplaySourceCustomBindings::DispatchSessionTerminated(int sink_id) const {
   v8::Isolate* isolate = context()->isolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context()->v8_context());
   v8::Local<v8::Array> event_args = v8::Array::New(isolate, 1);
   event_args->Set(0, v8::Integer::New(isolate, sink_id));
   context()->DispatchEvent("displaySource.onSessionTerminated", event_args);
 }
@@ skipping 24 matching lines @@
 
 DisplaySourceSession* DisplaySourceCustomBindings::GetDisplaySession(
     int sink_id) const {
   auto iter = session_map_.find(sink_id);
   if (iter != session_map_.end())
     return iter->second.get();
   return nullptr;
 }
 
 void DisplaySourceCustomBindings::OnSessionStarted(int sink_id) {
-  DispatchSessionStarted(sink_id);
+  CallCompletionCallback(sink_id, kStarted);
 }
 
 void DisplaySourceCustomBindings::OnSessionTerminated(int sink_id) {
   DisplaySourceSession* session = GetDisplaySession(sink_id);
   CHECK(session);
   session_map_.erase(sink_id);
   DispatchSessionTerminated(sink_id);
+  CallCompletionCallback(sink_id, kTerminated);
 }
 
 void DisplaySourceCustomBindings::OnSessionError(int sink_id,
                                                  DisplaySourceErrorType type,
                                                  const std::string& message) {
   DisplaySourceSession* session = GetDisplaySession(sink_id);
   CHECK(session);
-  if (session->state() != DisplaySourceSession::Established &&
-      session->state() != DisplaySourceSession::Terminating) {
-    // Error has occured before the session has actually started,
-    // no need to wait for session termination notification.
-    session_map_.erase(sink_id);
-  }
-
   DispatchSessionError(sink_id, type, message);
 }
 
+DisplaySourceCustomBindings::CallbackInfo
+DisplaySourceCustomBindings::GetCallbackInfo(
+    DisplaySourceCustomBindings::CallbackType type,
+    int sink_id) const {
+  static int sCallId;

[asargent_no_longer_on_chrome, 2016/02/11 17:14:00]

Consider initializing to 0 just so that readers don't have to worry about
remembering/looking up details about in what cases variable zero-initialization
is guaranteed by the C++ standard and in which cases it's implementation
dependent. (I think in this case it's guaranteed)

+  return {type, sink_id, ++sCallId};
+}
+
 }  // extensions