chromium通信系统-ipcz系统(十)-消息通知（trap）

最新推荐文章于 2024-07-22 18:57:27 发布

TangGeeA

最新推荐文章于 2024-07-22 18:57:27 发布

阅读量920

点赞数 19

分类专栏： chromium 文章标签： mojo chromium chrome ipcz

本文链接：https://blog.csdn.net/woai110120130/article/details/135448739

版权

chromium 专栏收录该内容

14 篇文章 2 订阅

订阅专栏

通过前面一系列ipcz的文章分析，我们了解到ipcz是在unix domain socket上层建立起了多个逻辑通道，所以对于上层的消息事件，不能单纯依赖io event 来触发，所以在ipcz系统中加入了trap的机制。 trap 的含义是陷阱，这个名字应该是来自cpu架构的概念，其实就是一种消息机制。在cpu中，执行分为中断和陷阱，陷阱是安插在程序指令流里面，当执行到了陷阱指令，就相当于掉入了陷阱中，这时候要调用陷阱处理程序来从陷阱中恢复出来。 ipcz的trap 机制则不同，它既有陷阱的含义，也有中断的含义。

我们都知道ipcz将来会取代mojo，不过现在还是混合使用的状态。所以目前有两层Trap。第一层是ipcz 层的trap，用于接收端口事件，该层主要的api是/third_party/ipcz/src/api.cc的Trap函数

IpczResult Trap(IpczHandle portal_handle,
                const IpczTrapConditions* conditions,
                IpczTrapEventHandler handler,
                uintptr_t context,
                uint32_t flags,
                const void* options,
                IpczTrapConditionFlags* satisfied_condition_flags,
                IpczPortalStatus* status)

Trap函数如果trap 关注的事件（conditions）没有满足，则会注册成功，否则返回IPCZ_RESULT_FAILED_PRECONDITION 表示前置条件不满足，满足的条件通过satisfied_condition_flags参数返回。这使得关注portal的事件有两个路径，一个是注册成功，后续事件触发导致回调，一个是注册失败，满足的条件通过satisfied_condition_flags 来返回。这给编程造成了一定困难，是不好的设计。

mojo层的Trap管理多个ipcz层的trap，每个Trap叫做一个Trigger。它主要的api是：


MojoResult MojoTrap::AddTrigger(MojoHandle handle,
                                MojoHandleSignals signals,
                                MojoTriggerCondition condition,
                                uintptr_t trigger_context)

由于MojoTrap管理多个Ipcz Trap， MojoTrap使用Trigger代表一个ipcz的trap。 AddTrigger为添加一个Trigger。由于添加时Trigger 不一定能添加进去（因为IPCZ_RESULT_FAILED_PRECONDITION），所以又增加了一个Arm函数，用于返回当前满足的状态，并注册为满足状态的trigger 到ipcz trap。

MojoResult MojoTrap::Arm(MojoTrapEvent* blocking_events,
                         uint32_t* num_blocking_events)

blocking_events 用于返回满足条件的Trigger对应的事件。

废话不多说我们直接通过代码分析。

我们先来看Trap对象的创建。
mojo/core/core_ipcz.cc

MojoResult MojoAddTriggerIpcz(MojoTrapEventHandler handler,
                              const MojoCreateTrapOptions* options,
                              MojoHandle* trap_handle) {
  if (!handler || !trap_handle) {
    return MOJO_RESULT_INVALID_ARGUMENT;
  }

  *trap_handle = ipcz_driver::MojoTrap::MakeBoxed(handler);
  return MOJO_RESULT_OK;
}

MojoCreateTrapIpcz的作用是创建一个Trap对象，有了这个Trap对象后，就可以想这个trap对象注册一些事件观察，当事件发生的时候就会向这些观察者发出通知。
参数handler 代表触发trap时的处理函数，这是一个回调函数。 trap_handle 是一个传输参数，是安装trap的句柄，用于向这个trap注册一下事件监听。
函数直接通过ipcz_driver::MojoTrap::MakeBoxed(handler) 创建MojoTrap， MakeBoxed我们前面已经分析过了，会调用MojoTrap的构造方法，我们看一下MojoTrap的构造方法。

MojoTrap::MojoTrap(MojoTrapEventHandler handler) : handler_(handler) {}

也很简单，只是设置了handler_成员变量。

我们再看下一个Trap相关api

MojoResult MojoAddTriggerIpcz(MojoHandle trap_handle,
                              MojoHandle handle,
                              MojoHandleSignals signals,
                              MojoTriggerCondition condition,
                              uintptr_t context,
                              const MojoAddTriggerOptions* options) {
  auto* trap = ipcz_driver::MojoTrap::FromBox(trap_handle);
  if (!trap) {
    return MOJO_RESULT_INVALID_ARGUMENT;
  }
  return trap->AddTrigger(handle, signals, condition, context);
}

MojoAddTriggerIpcz 函数顾名思义就是向trap添加一个触发器，用于注册trap 事件观察者，参数trap_handle 是用于指向MojoTrap的句柄，handle 是 portal的句柄，也就是添加的触发器针对与portal 上面的事件。signals则代表观察的具体事件，比如portal可读、可写等。 condition 就是表示触发器具体触发的条件，比如既可以在管道可读时触发，也可以在管道变为不可读时触发。 context参数用于回调函数的参数，是注册触发器时候给的上下文信息，这是回调场景中常用的手段。

MojoAddTriggerIpcz 函数代码逻辑也很简单，就是调用MojoTrap->AddTrigger() 方法添加触发器。在分析addTrigger之前我们先给出MojoHandleSignals 和MojoTriggerCondition的枚举值。

MojoHandleSignals：

MOJO_HANDLE_SIGNAL_READABLE： portal可读
MOJO_HANDLE_SIGNAL_WRITABLE: portal可写
MOJO_HANDLE_SIGNAL_PEER_CLOSED：portal 对端关闭
MOJO_HANDLE_SIGNAL_PEER_REMOTE：portal对等点在另一个进程中
MOJO_HANDLE_SIGNAL_QUOTA_EXCEEDED：超过某个限额
限额包括如下
- receive_queue_length_limit_;
- receive_queue_memory_size_limit_;
- unread_message_count_limit_;

MojoTriggerCondition：

MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED 不满足条件触发
MOJO_TRIGGER_CONDITION_SIGNALS_SATISFIED 满足条件触发

对于信号和触发条件我们有了了解，继续分析MojoTrap->AddTrigger()函数。

195 MojoResult MojoTrap::AddTrigger(MojoHandle handle,
196                                 MojoHandleSignals signals,
197                                 MojoTriggerCondition condition,
198                                 uintptr_t trigger_context) {
      .....
205   auto* data_pipe = DataPipe::FromBox(handle);
206   scoped_refptr<DataPipe::PortalWrapper> control_portal;
      // 如果handle 是data_pipem 获取control_portal
207   if (data_pipe) {
208     control_portal = data_pipe->GetPortal();
209     if (!control_portal) {
210       return MOJO_RESULT_INVALID_ARGUMENT;
211     }
212     handle = control_portal->handle();
213   } else if (ObjectBase::FromBox(handle)) {
214     // Any other type of driver object cannot have traps installed.
215     return MOJO_RESULT_INVALID_ARGUMENT;
216   }
217 
      // 创建Trigger对象
218   auto trigger = base::MakeRefCounted<Trigger>(this, handle, data_pipe, signals,
219                                                trigger_context);
220 
221   if (condition == MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED) {
         // MOJO_TRIGGER_CONDITION_SIGNALS_UNSATISFIED 这个功能废弃了
227   } else if (data_pipe) { 
        // data_pipe 类型处理
228     GetConditionsForDataPipeSignals(signals, &trigger->conditions);
229   } else {
        // portal 处理
230     GetConditionsForMessagePipeSignals(signals, &trigger->conditions);
231   }
232 
233   base::AutoLock lock(lock_);
      // 维护triggers_ 和 trigger的关系
234   auto [it, ok] = triggers_.try_emplace(trigger_context, trigger);
235   if (!ok) {
236     return MOJO_RESULT_ALREADY_EXISTS;
237   }
238 
239   next_trigger_ = triggers_.begin();
240 
241   // Install an ipcz trap to effectively monitor the lifetime of the watched
242   // object referenced by `handle`. Installation of the trap should always
243   // succeed, and its resulting trap event will always mark the end of this
244   // trigger's lifetime. This trap effectively owns a ref to the Trigger, as
245   // added here.
246   trigger->AddRef();
247   IpczTrapConditions removal_conditions = {
248       .size = sizeof(removal_conditions),
249       .flags = IPCZ_TRAP_REMOVED,
250   };
      // 向ipcz 注册Trap， TrapRemovalEventHandler是trap被移除的回调函数
251   IpczResult result = GetIpczAPI().Trap(
252       handle, &removal_conditions, &TrapRemovalEventHandler,
253       trigger->ipcz_context(), IPCZ_NO_FLAGS, nullptr, nullptr, nullptr);
254   CHECK_EQ(result, IPCZ_RESULT_OK);
255 
256   if (!armed_) {// 有其他trigger 没有安装上， 则返回MOJO_RESULT_OK，暂不安装trigger。
257     return MOJO_RESULT_OK;
258   }
259 
260   // The Mojo trap is already armed, so attempt to install an ipcz trap for
261   // the new trigger immediately.
262   MojoTrapEvent event;
      // 安装trigger
263   result = ArmTrigger(*trigger, event);
264   if (result == IPCZ_RESULT_OK) { // 没获取到，说明事件不属于该触发器，直接返回
265     return MOJO_RESULT_OK;
266   }
267 
268   // The new trigger already needs to fire an event. OK.
      // 该触发器有事件要处理，派发时间
269   armed_ = false;
270   DispatchOrQueueEvent(*trigger, event);
271   return MOJO_RESULT_OK;
272 }

Trap api分为两层。上层是MojoTrap，它可以管理多个ipcz trap， ipcz trap 在MojoTrap中叫做Trigger。
触发器支持DataPipe和Portal的事件触发。218行创建Trigger对象，251-253行向Ipcz层注册Trigger对象，注意这里的IpczTrapConditions->flags 为IPCZ_TRAP_REMOVED，这表示不关注portal其他事件，只关注ipcz trap被移除的事件。 256-258行如果MojoTrap上有其他trigger 没有安装到ipcz trap，则直接返回，等待一起安装。 262-266 其他Trigger 都成功安装则这里可以安装当前Trigger到ipcz trap，这里使用ArmTrigger 函数安装ipcz trap，如果安装成功直接返回，安装失败则表示当前trigger 已经被触发，调用DispatchOrQueueEvent派发事件。

我们先来看一下事件的派发。

528 void MojoTrap::DispatchOrQueueEvent(Trigger& trigger,
529                                     const MojoTrapEvent& event) {
530   lock_.AssertAcquired();
531   if (dispatching_thread_ == base::PlatformThread::CurrentRef()) {
532     // This thread is already dispatching an event, so queue this one. It will
533     // be dispatched before the thread fully unwinds from its current dispatch.
        // 当前线程正在派发事件，添加到pending_mojo_events_中
534     pending_mojo_events_->emplace_back(base::WrapRefCounted(&trigger), event);
535     return;
536   }
537 
538   // Block as long as any other thread is dispatching.
      // 同时只能有一个线程派发事件，其他线程在派发，等待
539   while (dispatching_thread_.has_value()) {
540     base::ScopedAllowBaseSyncPrimitivesOutsideBlockingScope allow_wait;
541     waiters_++;
542     dispatching_condition_.Wait();
543     waiters_--;
544   }
545 
546   dispatching_thread_ = base::PlatformThread::CurrentRef();
      // 派发事件
547   DispatchEvent(event);
548 
549   // NOTE: This vector is only shrunk by the clear() below, but it may
550   // accumulate more events during each iteration. Hence we iterate by index.
551   for (size_t i = 0; i < pending_mojo_events_->size(); ++i) {
552     if (!pending_mojo_events_[i].trigger->removed ||
553         pending_mojo_events_[i].event.result == MOJO_RESULT_CANCELLED) {
          // 派发pending_mojo_events_
554       DispatchEvent(pending_mojo_events_[i].event);
555     }
556   }
557   pending_mojo_events_->clear();
558 
559   // We're done. Give other threads a chance.
560   dispatching_thread_.reset();
561   if (waiters_ > 0) {
        // 通知等待者
562     dispatching_condition_.Signal();
563   }
564 }

DispatchOrQueueEvent函数代码很简单，保证同时只有一个线程派发事件，通过调用DispatchEvent函数进行事件派发。

566 void MojoTrap::DispatchEvent(const MojoTrapEvent& event) {
567   lock_.AssertAcquired();
568   DCHECK(dispatching_thread_ == base::PlatformThread::CurrentRef());
569 
570   // Note that other threads may enter DispatchOrQueueEvent while this is
571   // unlocked; but they will be blocked from dispatching since we've set
572   // `dispatching_thread_` to our thread.
573   base::AutoUnlock unlock(lock_);
574   handler_(&event);
575 }

DispatchEvent 调用创建MojoTrap时候传入的回调函数。参数为MojoTrapEvent。

再来看ipcz trap的注册。
third_party/ipcz/src/api.cc
我们继续分析向ipcz层注册Trap。

257 IpczResult Trap(IpczHandle portal_handle,
258                 const IpczTrapConditions* conditions,
259                 IpczTrapEventHandler handler,
260                 uintptr_t context,
261                 uint32_t flags,
262                 const void* options,
263                 IpczTrapConditionFlags* satisfied_condition_flags,
264                 IpczPortalStatus* status) {
265   ipcz::Portal* portal = ipcz::Portal::FromHandle(portal_handle);
266   if (!portal || !handler || !conditions ||
267       conditions->size < sizeof(*conditions)) {
268     return IPCZ_RESULT_INVALID_ARGUMENT;
269   }
270 
271   if (status && status->size < sizeof(*status)) {
272     return IPCZ_RESULT_INVALID_ARGUMENT;
273   }
274 
275   return portal->router()->Trap(*conditions, handler, context,
276                                 satisfied_condition_flags, status);
277 }

参数portal_handle 指向portal，conditions 表示关注portal的信号条件，比如trap被移除的回调。 trap 本身关心的事件在context的成员变量中。satisfied_condition_flags 是传出参数，表示给定的conditions下当前满足的条件。status用于查询端口的状态。
函数也比较简单，调用router->Trap 方法注册ipcz层的trap。

third_party/ipcz/src/ipcz/router.cc

IpczResult Router::Trap(const IpczTrapConditions& conditions,
                        IpczTrapEventHandler handler,
                        uint64_t context,
                        IpczTrapConditionFlags* satisfied_condition_flags,
                        IpczPortalStatus* status) {
  absl::MutexLock lock(&mutex_);
  return traps_.Add(conditions, handler, context, status_,
                    satisfied_condition_flags, status);
}

Router对象使用traps_维护多个Trap，我们来看一下它的代码.

third_party/ipcz/src/ipcz/trap_set.cc

 63 IpczResult TrapSet::Add(const IpczTrapConditions& conditions,
 64                         IpczTrapEventHandler handler,
 65                         uintptr_t context,
 66                         const IpczPortalStatus& current_status,
 67                         IpczTrapConditionFlags* satisfied_condition_flags,
 68                         IpczPortalStatus* status) {
 69   last_known_status_ = current_status;
 70   IpczTrapConditionFlags flags =
 71       GetSatisfiedConditions(conditions, current_status);
 72   if (flags != 0) {
 73     if (satisfied_condition_flags) {
 74       *satisfied_condition_flags = flags;
 75     }
 76     if (status) {
 77       // Note that we copy the minimum number of bytes between the size of our
 78       // IpczPortalStatus and the size of the caller's, which may differ if
 79       // coming from another version of ipcz. The `size` field is updated to
 80       // reflect how many bytes are actually meaningful here.
 81       const uint32_t size = std::min(status->size, sizeof(current_status));
 82       memcpy(status, &current_status, size);
 83       status->size = size;
 84     }
 85     return IPCZ_RESULT_FAILED_PRECONDITION;
 86   }
 87 
 88   traps_.emplace_back(conditions, handler, context);
 89   return IPCZ_RESULT_OK;
 90 }

参数current_status 是出入参数，为Router对象的status_成员变量。 status为传出参数。conditions则表示关注的条件。

70-71行通过router的状态和关注的条件，返回满足的条件。
73-74行给传出参数satisfied_condition_flags 赋值，设置为conditions下当前满足的条件。
76-84行给传出参数status赋值。
注意72-85行，整体上如果当前已经有满足的条件，则不注册trap，返回IPCZ_RESULT_FAILED_PRECONDITION，也就是前置条件不满足。
最后如果没有满足的条件则trap注册成功。向traps_成员变量添加一个Trap对象。

在 MojoTrap::AddTrigger中给定的条件为IPCZ_TRAP_REMOVED, 这个条件在trap被移除时触发，所以这里一定会添加trap成功。也就是MojoTrap::AddTrigger 只关注Ipcz Trap被移除事件，也就是它的生命周期。对应的MojoTrap::TrapRemovalEventHandler(const IpczTrapEvent* event) 函数我们就不分析了，它的作用主要是用于清理资源。

我们再看ArmTrigger函数，真正注册Trigger 到ipcz trap。

453 IpczResult MojoTrap::ArmTrigger(Trigger& trigger, MojoTrapEvent& event) {
454   lock_.AssertAcquired();
      ......
469   DataPipe* const data_pipe = trigger.data_pipe.get();
      ......
474   if (!data_pipe && (trigger.signals & MOJO_HANDLE_SIGNAL_WRITABLE)) {
        // data_pipe 永远可写，直接返回IPCZ_RESULT_FAILED_PRECONDITION
475     // Message pipes are always writable, so a trap watching for writability can
476     // never be armed.
477     IpczPortalStatus status = {.size = sizeof(status)};
478     const IpczResult result = GetIpczAPI().QueryPortalStatus(
479         trigger.handle, IPCZ_NO_FLAGS, nullptr, &status);
480     if (result == IPCZ_RESULT_OK) {
481       PopulateEventForMessagePipe(trigger.signals, status, event);
482     }
483     return IPCZ_RESULT_FAILED_PRECONDITION;
484   }
485 
486   // Bump the ref count on the Trigger. This ref is effectively owned by the
487   // trap if it's installed successfully.
488   trigger.AddRef();
489   IpczTrapConditionFlags satisfied_flags;
490   IpczPortalStatus status = {.size = sizeof(status)};
      // 依然调用ipcz 层的Trap函数，不过这里使用的conditions为真正的trigger conditions
491   IpczResult result =
492       GetIpczAPI().Trap(trigger.handle, &trigger.conditions, &TrapEventHandler,
493                         trigger.ipcz_context(), IPCZ_NO_FLAGS, nullptr,
494                         &satisfied_flags, &status);
495   if (result == IPCZ_RESULT_OK) {
496     trigger.armed = true;
497     return MOJO_RESULT_OK;
498   }
499 
500   // Balances the AddRef above since no trap was installed.
501   trigger.Release();
502 
503   if (data_pipe) {
504     PopulateEventForDataPipe(*data_pipe, trigger.signals, event);
505   } else {
506     PopulateEventForMessagePipe(trigger.signals, status, event);
507   }
508   return result;
509 }

函数依然调用ipcz层的Trap函数去注册trigger，不过这里的conditions已经换成了trigger的真正conditions。同样conditions如果满足则会返回IPCZ_RESULT_FAILED_PRECONDITION。函数503-507行就是处理这种情况，我们只看PopulateEventForMessagePipe函数

void PopulateEventForMessagePipe(MojoHandleSignals trigger_signals,
                                 const IpczPortalStatus& current_status,
                                 MojoTrapEvent& event) {
  const MojoHandleSignals kRead = MOJO_HANDLE_SIGNAL_READABLE;
  const MojoHandleSignals kWrite = MOJO_HANDLE_SIGNAL_WRITABLE;
  const MojoHandleSignals kPeerClosed = MOJO_HANDLE_SIGNAL_PEER_CLOSED;

  MojoHandleSignals& satisfied = event.signals_state.satisfied_signals;
  MojoHandleSignals& satisfiable = event.signals_state.satisfiable_signals;

  satisfied = 0;
  satisfiable = kPeerClosed | MOJO_HANDLE_SIGNAL_QUOTA_EXCEEDED;
  if (!(current_status.flags & IPCZ_PORTAL_STATUS_DEAD)) {
    satisfiable |= kRead;
  }

  if (current_status.flags & IPCZ_PORTAL_STATUS_PEER_CLOSED) {
    satisfied |= kPeerClosed;
  } else {
    satisfiable |= MOJO_HANDLE_SIGNAL_PEER_REMOTE | kWrite;
    satisfied |= kWrite;
  }

  if (current_status.num_local_parcels > 0) {
    satisfied |= kRead;
  }

  DCHECK((satisfied & satisfiable) == satisfied);
  GetEventResultForSignalsState(event.signals_state, trigger_signals,
                                event.result);
}

函数主要根据当前状态装填MojoTrapEvent这个传输参数。所以在MojoTrap::AddTrigger() 函数中可以直接派发event。

假如MojoTrap.armed_为false什么时候去注册Trap呢，一般这种情况需要主动调用MojoArmTrapIpcz函数。 MojoArmTrapIpcz函数的作用是注册MojoTrap的trigger 到ipcz trap。如果有trigger 已经满足条件，则返回满足条件的MojoTrapEvent。把能注册上的Trigger 进行注册。

MojoResult MojoArmTrapIpcz(MojoHandle trap_handle,
                           const MojoArmTrapOptions* options,
                           uint32_t* num_blocking_events,
                           MojoTrapEvent* blocking_events) {
  auto* trap = ipcz_driver::MojoTrap::FromBox(trap_handle);
  if (!trap) {
    return MOJO_RESULT_INVALID_ARGUMENT;
  }
  return trap->Arm(blocking_events, num_blocking_events);
}

函数参数trap_handle 为创建的MojoTrap的句柄， blocking_events 用户返回已经满足条件的Trigger 所触发的时间， num_blocking_events为blocking_events 的容量。

这个设计看起来很不统一。

mojo/core/ipcz_driver/mojo_trap.cc

289 MojoResult MojoTrap::Arm(MojoTrapEvent* blocking_events,
290                          uint32_t* num_blocking_events) {
     ......

302   base::AutoLock lock(lock_);
303   if (armed_) { // 已经有事件被触发，并且没被处理，则没有阻塞事件，返回MOJO_RESULT_OK
304     return MOJO_RESULT_OK;
305   }
306 
      // 没有注册的触发器，返回MOJO_RESULT_NOT_FOUND
307   if (triggers_.empty()) {
308     return MOJO_RESULT_NOT_FOUND;
309   }
310 
311   uint32_t num_events_returned = 0;
312   auto increment_wrapped = [this](TriggerMap::iterator it) {
313     lock_.AssertAcquired();
314     if (++it != triggers_.end()) {
315       return it;
316     }
317     return triggers_.begin();
318   };
319 
320   TriggerMap::iterator next_trigger = next_trigger_;
321   DCHECK(next_trigger != triggers_.end());
322 
323   // We iterate over all triggers, starting just beyond wherever we started last
324   // time we were armed. This guards against any single trigger being starved.
325   const TriggerMap::iterator end_trigger = next_trigger;
326   do {
327     auto& [trigger_context, trigger] = *next_trigger;
328     next_trigger = increment_wrapped(next_trigger);
329 
330     MojoTrapEvent event;
        // 安装trigger
331     const IpczResult result = ArmTrigger(*trigger, event);
332     if (result == IPCZ_RESULT_OK) { // 已经触发，下一个
333       // Trap successfully installed, nothing else to do for this trigger.
334       continue;
335     }
336 
337     if (result != IPCZ_RESULT_FAILED_PRECONDITION) {
338       NOTREACHED();
339       return result;
340     }
341 
342     // The ipcz trap failed to install, so this trigger's conditions are already
343     // met. Accumulate would-be event details if there's output space.
344     if (event_capacity == 0) {
345       return MOJO_RESULT_FAILED_PRECONDITION;
346     }
347 
348     blocking_events[num_events_returned++] = event;
349   } while (next_trigger != end_trigger &&
350            (num_events_returned == 0 || num_events_returned < event_capacity));
351 
352   if (next_trigger != end_trigger) {
353     next_trigger_ = next_trigger;
354   } else {
355     next_trigger_ = increment_wrapped(next_trigger);
356   }
357 
358   if (num_events_returned > 0) {
359     *num_blocking_events = num_events_returned;
360     return MOJO_RESULT_FAILED_PRECONDITION;
361   }
362 
363   // The whole Mojo trap is collectively armed if and only if all of the
364   // triggers managed to install an ipcz trap.
      // 全部都安装上了
365   armed_ = true;
366   return MOJO_RESULT_OK;
367 }

函数主要调用ArmTrigger去安装ipcz trap，如果安装失败则代表该Trigger 已经触发，或者其他前置条件不满足，原因会通过MojoTrapEvent传出。如果全部Trigger 都注册成功则设置armed_=true。

TangGeeA

关注

19
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
chromium通信系统-ipcz系统(十)-消息通知（trap）

MojoAddTriggerIpcz 函数顾名思义就是向trap添加一个触发器，用于注册trap 事件观察者，参数trap_handle 是用于指向MojoTrap的句柄，handle 是 portal的句柄，也就是添加的触发器针对与portal 上面的事件。Trap函数如果trap 关注的事件（conditions）没有满足，则会注册成功，否则返回IPCZ_RESULT_FAILED_PRECONDITION 表示前置条件不满足，满足的条件通过satisfied_condition_flags参数返回。
复制链接

扫一扫

专栏目录